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

1585 lines
52KB
Raw Blame History 

  1. /*

  2.  * JackBridge (Part 1, JACK functions)

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

  487. static JackBridge bridge;

  488. 

  489. #endif // ! JACKBRIDGE_DIRECT

  490. 

  491. // -----------------------------------------------------------------------------

  492. 

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

  494. {

  495. #if defined(JACKBRIDGE_DUMMY)

  496. #elif defined(JACKBRIDGE_DIRECT)

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

  498. #else

  499.     if (bridge.get_version_ptr != nullptr)

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

  501. #endif

  502.     if (major_ptr != nullptr)

  503.         *major_ptr = 0;

  504.     if (minor_ptr != nullptr)

  505.         *minor_ptr = 0;

  506.     if (micro_ptr != nullptr)

  507.         *micro_ptr = 0;

  508.     if (proto_ptr != nullptr)

  509.         *proto_ptr = 0;

  510. }

  511. 

  512. const char* jackbridge_get_version_string()

  513. {

  514. #if defined(JACKBRIDGE_DUMMY)

  515. #elif defined(JACKBRIDGE_DIRECT)

  516.     return jack_get_version_string();

  517. #else

  518.     if (bridge.get_version_string_ptr != nullptr)

  519.         return bridge.get_version_string_ptr();

  520. #endif

  521.     return nullptr;

  522. }

  523. 

  524. // -----------------------------------------------------------------------------

  525. 

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

  527. {

  528. #if defined(JACKBRIDGE_DUMMY)

  529. #elif defined(JACKBRIDGE_DIRECT)

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

  531. #else

  532.     if (bridge.client_open_ptr != nullptr)

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

  534. #endif

  535.     if (status != nullptr)

  536.         *status = JackServerError;

  537.     return nullptr;

  538. }

  539. 

  540. bool jackbridge_client_close(jack_client_t* client)

  541. {

  542. #if defined(JACKBRIDGE_DUMMY)

  543. #elif defined(JACKBRIDGE_DIRECT)

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

  545. #else

  546.     if (bridge.client_close_ptr != nullptr)

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

  548. #endif

  549.     return false;

  550. }

  551. 

  552. // -----------------------------------------------------------------------------

  553. 

  554. int jackbridge_client_name_size()

  555. {

  556. #if defined(JACKBRIDGE_DUMMY)

  557. #elif defined(JACKBRIDGE_DIRECT)

  558.     return jack_client_name_size();

  559. #else

  560.     if (bridge.client_name_size_ptr != nullptr)

  561.         return bridge.client_name_size_ptr();

  562. #endif

  563.     return 0;

  564. }

  565. 

  566. char* jackbridge_get_client_name(jack_client_t* client)

  567. {

  568. #if defined(JACKBRIDGE_DUMMY)

  569. #elif defined(JACKBRIDGE_DIRECT)

  570.     return jack_get_client_name(client);

  571. #else

  572.     if (bridge.get_client_name_ptr != nullptr)

  573.         return bridge.get_client_name_ptr(client);

  574. #endif

  575.     return nullptr;

  576. }

  577. 

  578. // -----------------------------------------------------------------------------

  579. 

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

  581. {

  582. #if defined(JACKBRIDGE_DUMMY)

  583. #elif defined(JACKBRIDGE_DIRECT)

  584.     return jack_get_uuid_for_client_name(client, name);

  585. #else

  586.     if (bridge.get_uuid_for_client_name_ptr != nullptr)

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

  588. #endif

  589.     return nullptr;

  590. }

  591. 

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

  593. {

  594. #if defined(JACKBRIDGE_DUMMY)

  595. #elif defined(JACKBRIDGE_DIRECT)

  596.     return jack_get_client_name_by_uuid(client, uuid);

  597. #else

  598.     if (bridge.get_client_name_by_uuid_ptr != nullptr)

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

  600. #endif

  601.     return nullptr;

  602. }

  603. 

  604. // -----------------------------------------------------------------------------

  605. 

  606. bool jackbridge_activate(jack_client_t* client)

  607. {

  608. #if defined(JACKBRIDGE_DUMMY)

  609. #elif defined(JACKBRIDGE_DIRECT)

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

  611. #else

  612.     if (bridge.activate_ptr != nullptr)

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

  614. #endif

  615.     return false;

  616. }

  617. 

  618. bool jackbridge_deactivate(jack_client_t* client)

  619. {

  620. #if defined(JACKBRIDGE_DUMMY)

  621. #elif defined(JACKBRIDGE_DIRECT)

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

  623. #else

  624.     if (bridge.deactivate_ptr != nullptr)

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

  626. #endif

  627.     return false;

  628. }

  629. 

  630. bool jackbridge_is_realtime(jack_client_t* client)

  631. {

  632. #if defined(JACKBRIDGE_DUMMY)

  633. #elif defined(JACKBRIDGE_DIRECT)

  634.     return jack_is_realtime(client);

  635. #else

  636.     if (bridge.is_realtime_ptr != nullptr)

  637.         return bridge.is_realtime_ptr(client);

  638. #endif

  639.     return false;

  640. }

  641. 

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

  643. 

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

  645. {

  646. #if defined(JACKBRIDGE_DUMMY)

  647. #elif defined(JACKBRIDGE_DIRECT)

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

  649. #else

  650.     if (bridge.set_thread_init_callback_ptr != nullptr)

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

  652. #endif

  653.     return false;

  654. }

  655. 

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

  657. {

  658. #if defined(JACKBRIDGE_DUMMY)

  659. #elif defined(JACKBRIDGE_DIRECT)

  660.     jack_on_shutdown(client, shutdown_callback, arg);

  661. #else

  662.     if (bridge.on_shutdown_ptr != nullptr)

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

  664. #endif

  665. }

  666. 

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

  668. {

  669. #if defined(JACKBRIDGE_DUMMY)

  670. #elif defined(JACKBRIDGE_DIRECT)

  671.     jack_on_info_shutdown(client, shutdown_callback, arg);

  672. #else

  673.     if (bridge.on_info_shutdown_ptr != nullptr)

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

  675. #endif

  676. }

  677. 

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

  679. {

  680. #if defined(JACKBRIDGE_DUMMY)

  681. #elif defined(JACKBRIDGE_DIRECT)

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

  683. #else

  684.     if (bridge.set_process_callback_ptr != nullptr)

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

  686. #endif

  687.     return false;

  688. }

  689. 

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

  691. {

  692. #if defined(JACKBRIDGE_DUMMY)

  693. #elif defined(JACKBRIDGE_DIRECT)

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

  695. #else

  696.     if (bridge.set_freewheel_callback_ptr != nullptr)

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

  698. #endif

  699.     return false;

  700. }

  701. 

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

  703. {

  704. #if defined(JACKBRIDGE_DUMMY)

  705. #elif defined(JACKBRIDGE_DIRECT)

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

  707. #else

  708.     if (bridge.set_buffer_size_callback_ptr != nullptr)

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

  710. #endif

  711.     return false;

  712. }

  713. 

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

  715. {

  716. #if defined(JACKBRIDGE_DUMMY)

  717. #elif defined(JACKBRIDGE_DIRECT)

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

  719. #else

  720.     if (bridge.set_sample_rate_callback_ptr != nullptr)

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

  722. #endif

  723.     return false;

  724. }

  725. 

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

  727. {

  728. #if defined(JACKBRIDGE_DUMMY)

  729. #elif defined(JACKBRIDGE_DIRECT)

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

  731. #else

  732.     if (bridge.set_client_registration_callback_ptr != nullptr)

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

  734. #endif

  735.     return false;

  736. }

  737. 

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

  739. {

  740. #if defined(JACKBRIDGE_DUMMY)

  741. #elif defined(JACKBRIDGE_DIRECT)

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

  743. #else

  744.     if (bridge.set_port_registration_callback_ptr != nullptr)

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

  746. #endif

  747.     return false;

  748. }

  749. 

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

  751. {

  752. #if defined(JACKBRIDGE_DUMMY)

  753. #elif defined(JACKBRIDGE_DIRECT)

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

  755. #else

  756.     if (bridge.set_port_rename_callback_ptr != nullptr)

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

  758. #endif

  759.     return false;

  760. }

  761. 

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

  763. {

  764. #if defined(JACKBRIDGE_DUMMY)

  765. #elif defined(JACKBRIDGE_DIRECT)

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

  767. #else

  768.     if (bridge.set_port_connect_callback_ptr != nullptr)

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

  770. #endif

  771.     return false;

  772. }

  773. 

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

  775. {

  776. #if defined(JACKBRIDGE_DUMMY)

  777. #elif defined(JACKBRIDGE_DIRECT)

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

  779. #else

  780.     if (bridge.set_xrun_callback_ptr != nullptr)

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

  782. #endif

  783.     return false;

  784. }

  785. 

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

  787. {

  788. #if defined(JACKBRIDGE_DUMMY)

  789. #elif defined(JACKBRIDGE_DIRECT)

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

  791. #else

  792.     if (bridge.set_latency_callback_ptr != nullptr)

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

  794. #endif

  795.     return false;

  796. }

  797. 

  798. // -----------------------------------------------------------------------------

  799. 

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

  801. {

  802. #if defined(JACKBRIDGE_DUMMY)

  803. #elif defined(JACKBRIDGE_DIRECT)

  804.     return jack_set_freewheel(client, onoff);

  805. #else

  806.     if (bridge.set_freewheel_ptr != nullptr)

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

  808. #endif

  809.     return false;

  810. }

  811. 

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

  813. {

  814. #if defined(JACKBRIDGE_DUMMY)

  815. #elif defined(JACKBRIDGE_DIRECT)

  816.     return jack_set_buffer_size(client, nframes);

  817. #else

  818.     if (bridge.set_buffer_size_ptr != nullptr)

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

  820. #endif

  821.     return false;

  822. }

  823. 

  824. // -----------------------------------------------------------------------------

  825. 

  826. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  827. {

  828. #if defined(JACKBRIDGE_DUMMY)

  829. #elif defined(JACKBRIDGE_DIRECT)

  830.     return jack_get_sample_rate(client);

  831. #else

  832.     if (bridge.get_sample_rate_ptr != nullptr)

  833.         return bridge.get_sample_rate_ptr(client);

  834. #endif

  835.     return 0;

  836. }

  837. 

  838. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  839. {

  840. #if defined(JACKBRIDGE_DUMMY)

  841. #elif defined(JACKBRIDGE_DIRECT)

  842.     return jack_get_buffer_size(client);

  843. #else

  844.     if (bridge.get_buffer_size_ptr != nullptr)

  845.         return bridge.get_buffer_size_ptr(client);

  846. #endif

  847.     return 0;

  848. }

  849. 

  850. float jackbridge_cpu_load(jack_client_t* client)

  851. {

  852. #if defined(JACKBRIDGE_DUMMY)

  853. #elif defined(JACKBRIDGE_DIRECT)

  854.     return jack_cpu_load(client);

  855. #else

  856.     if (bridge.cpu_load_ptr != nullptr)

  857.         return bridge.cpu_load_ptr(client);

  858. #endif

  859.     return 0.0f;

  860. }

  861. 

  862. // -----------------------------------------------------------------------------

  863. 

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

  865. {

  866. #if defined(JACKBRIDGE_DUMMY)

  867. #elif defined(JACKBRIDGE_DIRECT)

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

  869. #else

  870.     if (bridge.port_register_ptr != nullptr)

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

  872. #endif

  873.     return nullptr;

  874. }

  875. 

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

  877. {

  878. #if defined(JACKBRIDGE_DUMMY)

  879. #elif defined(JACKBRIDGE_DIRECT)

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

  881. #else

  882.     if (bridge.port_unregister_ptr != nullptr)

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

  884. #endif

  885.     return false;

  886. }

  887. 

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

  889. {

  890. #if defined(JACKBRIDGE_DUMMY)

  891. #elif defined(JACKBRIDGE_DIRECT)

  892.     return jack_port_get_buffer(port, nframes);

  893. #else

  894.     if (bridge.port_get_buffer_ptr != nullptr)

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

  896. #endif

  897.     return nullptr;

  898. }

  899. 

  900. // -----------------------------------------------------------------------------

  901. 

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

  903. {

  904. #if defined(JACKBRIDGE_DUMMY)

  905. #elif defined(JACKBRIDGE_DIRECT)

  906.     return jack_port_name(port);

  907. #else

  908.     if (bridge.port_name_ptr != nullptr)

  909.         return bridge.port_name_ptr(port);

  910. #endif

  911.     return nullptr;

  912. }

  913. 

  914. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  915. {

  916. #if defined(JACKBRIDGE_DUMMY)

  917. #elif defined(JACKBRIDGE_DIRECT)

  918.     return jack_port_uuid(port);

  919. #else

  920.     if (bridge.port_uuid_ptr != nullptr)

  921.         return bridge.port_uuid_ptr(port);

  922. #endif

  923.     return 0;

  924. }

  925. 

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

  927. {

  928. #if defined(JACKBRIDGE_DUMMY)

  929. #elif defined(JACKBRIDGE_DIRECT)

  930.     return jack_port_short_name(port);

  931. #else

  932.     if (bridge.port_short_name_ptr != nullptr)

  933.         return bridge.port_short_name_ptr(port);

  934. #endif

  935.     return nullptr;

  936. }

  937. 

  938. int jackbridge_port_flags(const jack_port_t* port)

  939. {

  940. #if defined(JACKBRIDGE_DUMMY)

  941. #elif defined(JACKBRIDGE_DIRECT)

  942.     return jack_port_flags(port);

  943. #else

  944.     if (bridge.port_flags_ptr != nullptr)

  945.         return bridge.port_flags_ptr(port);

  946. #endif

  947.     return 0x0;

  948. }

  949. 

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

  951. {

  952. #if defined(JACKBRIDGE_DUMMY)

  953. #elif defined(JACKBRIDGE_DIRECT)

  954.     return jack_port_type(port);

  955. #else

  956.     if (bridge.port_type_ptr != nullptr)

  957.         return bridge.port_type_ptr(port);

  958. #endif

  959.     return nullptr;

  960. }

  961. 

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

  963. {

  964. #if defined(JACKBRIDGE_DUMMY)

  965. #elif defined(JACKBRIDGE_DIRECT)

  966.     return jack_port_is_mine(client, port);

  967. #else

  968.     if (bridge.port_is_mine_ptr != nullptr)

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

  970. #endif

  971.     return false;

  972. }

  973. 

  974. int jackbridge_port_connected(const jack_port_t* port)

  975. {

  976. #if defined(JACKBRIDGE_DUMMY)

  977. #elif defined(JACKBRIDGE_DIRECT)

  978.     return jack_port_connected(port);

  979. #else

  980.     if (bridge.port_connected_ptr != nullptr)

  981.         return bridge.port_connected_ptr(port);

  982. #endif

  983.     return 0;

  984. }

  985. 

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

  987. {

  988. #if defined(JACKBRIDGE_DUMMY)

  989. #elif defined(JACKBRIDGE_DIRECT)

  990.     return jack_port_connected_to(port, port_name);

  991. #else

  992.     if (bridge.port_connected_to_ptr != nullptr)

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

  994. #endif

  995.     return false;

  996. }

  997. 

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

  999. {

  1000. #if defined(JACKBRIDGE_DUMMY)

  1001. #elif defined(JACKBRIDGE_DIRECT)

  1002.     return jack_port_get_connections(port);

  1003. #else

  1004.     if (bridge.port_get_connections_ptr != nullptr)

  1005.         return bridge.port_get_connections_ptr(port);

  1006. #endif

  1007.     return nullptr;

  1008. }

  1009. 

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

  1011. {

  1012. #if defined(JACKBRIDGE_DUMMY)

  1013. #elif defined(JACKBRIDGE_DIRECT)

  1014.     return jack_port_get_all_connections(client, port);

  1015. #else

  1016.     if (bridge.port_get_all_connections_ptr != nullptr)

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

  1018. #endif

  1019.     return nullptr;

  1020. }

  1021. 

  1022. // -----------------------------------------------------------------------------

  1023. 

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

  1025. {

  1026. #if defined(JACKBRIDGE_DUMMY)

  1027. #elif defined(JACKBRIDGE_DIRECT)

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

  1029. #else

  1030.     if (bridge.port_set_name_ptr != nullptr)

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

  1032. #endif

  1033.     return false;

  1034. }

  1035. 

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

  1037. {

  1038. #if defined(JACKBRIDGE_DUMMY)

  1039. #elif defined(JACKBRIDGE_DIRECT)

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

  1041. #else

  1042.     if (bridge.port_set_alias_ptr != nullptr)

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

  1044. #endif

  1045.     return false;

  1046. }

  1047. 

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

  1049. {

  1050. #if defined(JACKBRIDGE_DUMMY)

  1051. #elif defined(JACKBRIDGE_DIRECT)

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

  1053. #else

  1054.     if (bridge.port_unset_alias_ptr != nullptr)

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

  1056. #endif

  1057.     return false;

  1058. }

  1059. 

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

  1061. {

  1062. #if defined(JACKBRIDGE_DUMMY)

  1063. #elif defined(JACKBRIDGE_DIRECT)

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

  1065. #else

  1066.     if (bridge.port_get_aliases_ptr != nullptr)

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

  1068. #endif

  1069.     return 0;

  1070. }

  1071. 

  1072. // -----------------------------------------------------------------------------

  1073. 

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

  1075. {

  1076. #if defined(JACKBRIDGE_DUMMY)

  1077. #elif defined(JACKBRIDGE_DIRECT)

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

  1079. #else

  1080.     if (bridge.port_request_monitor_ptr != nullptr)

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

  1082. #endif

  1083.     return false;

  1084. }

  1085. 

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

  1087. {

  1088. #if defined(JACKBRIDGE_DUMMY)

  1089. #elif defined(JACKBRIDGE_DIRECT)

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

  1091. #else

  1092.     if (bridge.port_request_monitor_by_name_ptr != nullptr)

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

  1094. #endif

  1095.     return false;

  1096. }

  1097. 

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

  1099. {

  1100. #if defined(JACKBRIDGE_DUMMY)

  1101. #elif defined(JACKBRIDGE_DIRECT)

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

  1103. #else

  1104.     if (bridge.port_ensure_monitor_ptr != nullptr)

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

  1106. #endif

  1107.     return false;

  1108. }

  1109. 

  1110. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1111. {

  1112. #if defined(JACKBRIDGE_DUMMY)

  1113. #elif defined(JACKBRIDGE_DIRECT)

  1114.     return jack_port_monitoring_input(port);

  1115. #else

  1116.     if (bridge.port_monitoring_input_ptr != nullptr)

  1117.         return bridge.port_monitoring_input_ptr(port);

  1118. #endif

  1119.     return false;

  1120. }

  1121. 

  1122. // -----------------------------------------------------------------------------

  1123. 

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

  1125. {

  1126. #if defined(JACKBRIDGE_DUMMY)

  1127. #elif defined(JACKBRIDGE_DIRECT)

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

  1129. #else

  1130.     if (bridge.connect_ptr != nullptr)

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

  1132. #endif

  1133.     return false;

  1134. }

  1135. 

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

  1137. {

  1138. #if defined(JACKBRIDGE_DUMMY)

  1139. #elif defined(JACKBRIDGE_DIRECT)

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

  1141. #else

  1142.     if (bridge.disconnect_ptr != nullptr)

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

  1144. #endif

  1145.     return false;

  1146. }

  1147. 

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

  1149. {

  1150. #if defined(JACKBRIDGE_DUMMY)

  1151. #elif defined(JACKBRIDGE_DIRECT)

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

  1153. #else

  1154.     if (bridge.port_disconnect_ptr != nullptr)

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

  1156. #endif

  1157.     return false;

  1158. }

  1159. 

  1160. // -----------------------------------------------------------------------------

  1161. 

  1162. int jackbridge_port_name_size()

  1163. {

  1164. #if defined(JACKBRIDGE_DUMMY)

  1165. #elif defined(JACKBRIDGE_DIRECT)

  1166.     return jack_port_name_size();

  1167. #else

  1168.     if (bridge.port_name_size_ptr != nullptr)

  1169.         return bridge.port_name_size_ptr();

  1170. #endif

  1171.     return 0;

  1172. }

  1173. 

  1174. int jackbridge_port_type_size()

  1175. {

  1176. #if defined(JACKBRIDGE_DUMMY)

  1177. #elif defined(JACKBRIDGE_DIRECT)

  1178.     return jack_port_type_size();

  1179. #else

  1180.     if (bridge.port_type_size_ptr != nullptr)

  1181.         return bridge.port_type_size_ptr();

  1182. #endif

  1183.     return 0;

  1184. }

  1185. 

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

  1187. {

  1188. #if defined(JACKBRIDGE_DUMMY)

  1189. #elif defined(JACKBRIDGE_DIRECT)

  1190.     return jack_port_type_get_buffer_size(client, port_type);

  1191. #else

  1192.     if (bridge.port_type_get_buffer_size_ptr != nullptr)

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

  1194. #endif

  1195.     return 0;

  1196. }

  1197. 

  1198. // -----------------------------------------------------------------------------

  1199. 

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

  1201. {

  1202. #if defined(JACKBRIDGE_DUMMY)

  1203. #elif defined(JACKBRIDGE_DIRECT)

  1204.     jack_port_get_latency_range(port, mode, range);

  1205. #else

  1206.     if (bridge.port_get_latency_range_ptr != nullptr)

  1207.         bridge.port_get_latency_range_ptr(port, mode, range);

  1208. #endif

  1209. }

  1210. 

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

  1212. {

  1213. #if defined(JACKBRIDGE_DUMMY)

  1214. #elif defined(JACKBRIDGE_DIRECT)

  1215.     jack_port_set_latency_range(port, mode, range);

  1216. #else

  1217.     if (bridge.port_set_latency_range_ptr != nullptr)

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

  1219. #endif

  1220. }

  1221. 

  1222. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1223. {

  1224. #if defined(JACKBRIDGE_DUMMY)

  1225. #elif defined(JACKBRIDGE_DIRECT)

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

  1227. #else

  1228.     if (bridge.recompute_total_latencies_ptr != nullptr)

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

  1230. #endif

  1231.     return false;

  1232. }

  1233. 

  1234. // -----------------------------------------------------------------------------

  1235. 

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

  1237. {

  1238. #if defined(JACKBRIDGE_DUMMY)

  1239. #elif defined(JACKBRIDGE_DIRECT)

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

  1241. #else

  1242.     if (bridge.get_ports_ptr != nullptr)

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

  1244. #endif

  1245.     return nullptr;

  1246. }

  1247. 

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

  1249. {

  1250. #if defined(JACKBRIDGE_DUMMY)

  1251. #elif defined(JACKBRIDGE_DIRECT)

  1252.     return jack_port_by_name(client, port_name);

  1253. #else

  1254.     if (bridge.port_by_name_ptr != nullptr)

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

  1256. #endif

  1257.     return nullptr;

  1258. }

  1259. 

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

  1261. {

  1262. #if defined(JACKBRIDGE_DUMMY)

  1263. #elif defined(JACKBRIDGE_DIRECT)

  1264.     return jack_port_by_id(client, port_id);

  1265. #else

  1266.     if (bridge.port_by_id_ptr != nullptr)

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

  1268. #endif

  1269.     return nullptr;

  1270. }

  1271. 

  1272. // -----------------------------------------------------------------------------

  1273. 

  1274. void jackbridge_free(void* ptr)

  1275. {

  1276. #if defined(JACKBRIDGE_DUMMY)

  1277. #elif defined(JACKBRIDGE_DIRECT)

  1278.     return jack_free(ptr);

  1279. #else

  1280.     if (bridge.free_ptr != nullptr)

  1281.         return bridge.free_ptr(ptr);

  1282. 

  1283.     // just in case

  1284.     std::free(ptr);

  1285. #endif

  1286. }

  1287. 

  1288. // -----------------------------------------------------------------------------

  1289. 

  1290. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1291. {

  1292. #if defined(JACKBRIDGE_DUMMY)

  1293. #elif defined(JACKBRIDGE_DIRECT)

  1294.     return jack_midi_get_event_count(port_buffer);

  1295. #else

  1296.     if (bridge.midi_get_event_count_ptr != nullptr)

  1297.         return bridge.midi_get_event_count_ptr(port_buffer);

  1298. #endif

  1299.     return 0;

  1300. }

  1301. 

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

  1303. {

  1304. #if defined(JACKBRIDGE_DUMMY)

  1305. #elif defined(JACKBRIDGE_DIRECT)

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

  1307. #else

  1308.     if (bridge.midi_event_get_ptr != nullptr)

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

  1310. #endif

  1311.     return false;

  1312. }

  1313. 

  1314. void jackbridge_midi_clear_buffer(void* port_buffer)

  1315. {

  1316. #if defined(JACKBRIDGE_DUMMY)

  1317. #elif defined(JACKBRIDGE_DIRECT)

  1318.     jack_midi_clear_buffer(port_buffer);

  1319. #else

  1320.     if (bridge.midi_clear_buffer_ptr != nullptr)

  1321.         bridge.midi_clear_buffer_ptr(port_buffer);

  1322. #endif

  1323. }

  1324. 

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

  1326. {

  1327. #if defined(JACKBRIDGE_DUMMY)

  1328. #elif defined(JACKBRIDGE_DIRECT)

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

  1330. #else

  1331.     if (bridge.midi_event_write_ptr != nullptr)

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

  1333. #endif

  1334.     return false;

  1335. }

  1336. 

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

  1338. {

  1339. #if defined(JACKBRIDGE_DUMMY)

  1340. #elif defined(JACKBRIDGE_DIRECT)

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

  1342. #else

  1343.     if (bridge.midi_event_reserve_ptr != nullptr)

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

  1345. #endif

  1346.     return nullptr;

  1347. }

  1348. 

  1349. // -----------------------------------------------------------------------------

  1350. 

  1351. bool jackbridge_release_timebase(jack_client_t* client)

  1352. {

  1353. #if defined(JACKBRIDGE_DUMMY)

  1354. #elif defined(JACKBRIDGE_DIRECT)

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

  1356. #else

  1357.     if (bridge.release_timebase_ptr != nullptr)

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

  1359. #endif

  1360.     return false;

  1361. }

  1362. 

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

  1364. {

  1365. #if defined(JACKBRIDGE_DUMMY)

  1366. #elif defined(JACKBRIDGE_DIRECT)

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

  1368. #else

  1369.     if (bridge.set_sync_callback_ptr != nullptr)

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

  1371. #endif

  1372.     return false;

  1373. }

  1374. 

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

  1376. {

  1377. #if defined(JACKBRIDGE_DUMMY)

  1378. #elif defined(JACKBRIDGE_DIRECT)

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

  1380. #else

  1381.     if (bridge.set_sync_timeout_ptr != nullptr)

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

  1383. #endif

  1384.     return false;

  1385. }

  1386. 

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

  1388. {

  1389. #if defined(JACKBRIDGE_DUMMY)

  1390. #elif defined(JACKBRIDGE_DIRECT)

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

  1392. #else

  1393.     if (bridge.set_timebase_callback_ptr != nullptr)

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

  1395. #endif

  1396.     return false;

  1397. }

  1398. 

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

  1400. {

  1401. #if defined(JACKBRIDGE_DUMMY)

  1402. #elif defined(JACKBRIDGE_DIRECT)

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

  1404. #else

  1405.     if (bridge.transport_locate_ptr != nullptr)

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

  1407. #endif

  1408.     return false;

  1409. }

  1410. 

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

  1412. {

  1413. #if defined(JACKBRIDGE_DUMMY)

  1414. #elif defined(JACKBRIDGE_DIRECT)

  1415.     return jack_transport_query(client, pos);

  1416. #else

  1417.     if (bridge.transport_query_ptr != nullptr)

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

  1419. #endif

  1420.     if (pos != nullptr)

  1421.     {

  1422.         // invalidate

  1423.         pos->unique_1 = 0;

  1424.         pos->unique_2 = 1;

  1425.     }

  1426.     return JackTransportStopped;

  1427. }

  1428. 

  1429. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1430. {

  1431. #if defined(JACKBRIDGE_DUMMY)

  1432. #elif defined(JACKBRIDGE_DIRECT)

  1433.     return jack_get_current_transport_frame(client);

  1434. #else

  1435.     if (bridge.get_current_transport_frame_ptr != nullptr)

  1436.         return bridge.get_current_transport_frame_ptr(client);

  1437. #endif

  1438.     return 0;

  1439. }

  1440. 

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

  1442. {

  1443. #if defined(JACKBRIDGE_DUMMY)

  1444. #elif defined(JACKBRIDGE_DIRECT)

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

  1446. #else

  1447.     if (bridge.transport_reposition_ptr != nullptr)

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

  1449. #endif

  1450.     return false;

  1451. }

  1452. 

  1453. void jackbridge_transport_start(jack_client_t* client)

  1454. {

  1455. #if defined(JACKBRIDGE_DUMMY)

  1456. #elif defined(JACKBRIDGE_DIRECT)

  1457.     jack_transport_start(client);

  1458. #else

  1459.     if (bridge.transport_start_ptr != nullptr)

  1460.         bridge.transport_start_ptr(client);

  1461. #endif

  1462. }

  1463. 

  1464. void jackbridge_transport_stop(jack_client_t* client)

  1465. {

  1466. #if defined(JACKBRIDGE_DUMMY)

  1467. #elif defined(JACKBRIDGE_DIRECT)

  1468.     jack_transport_stop(client);

  1469. #else

  1470.     if (bridge.transport_stop_ptr != nullptr)

  1471.         bridge.transport_stop_ptr(client);

  1472. #endif

  1473. }

  1474. 

  1475. // -----------------------------------------------------------------------------

  1476. 

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

  1478. {

  1479. #if defined(JACKBRIDGE_DUMMY)

  1480. #elif defined(JACKBRIDGE_DIRECT)

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

  1482. #else

  1483.     if (bridge.set_property_ptr != nullptr)

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

  1485. #endif

  1486.     return false;

  1487. }

  1488. 

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

  1490. {

  1491. #if defined(JACKBRIDGE_DUMMY)

  1492. #elif defined(JACKBRIDGE_DIRECT)

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

  1494. #else

  1495.     if (bridge.get_property_ptr != nullptr)

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

  1497. #endif

  1498.     return false;

  1499. }

  1500. 

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

  1502. {

  1503. #if defined(JACKBRIDGE_DUMMY)

  1504. #elif defined(JACKBRIDGE_DIRECT)

  1505.     jack_free_description(desc, free_description_itself);

  1506. #else

  1507.     if (bridge.free_description_ptr != nullptr)

  1508.         bridge.free_description_ptr(desc, free_description_itself);

  1509. #endif

  1510. }

  1511. 

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

  1513. {

  1514. #if defined(JACKBRIDGE_DUMMY)

  1515. #elif defined(JACKBRIDGE_DIRECT)

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

  1517. #else

  1518.     if (bridge.get_properties_ptr != nullptr)

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

  1520. #endif

  1521.     return false;

  1522. }

  1523. 

  1524. bool jackbridge_get_all_properties(jack_description_t** descs)

  1525. {

  1526. #if defined(JACKBRIDGE_DUMMY)

  1527. #elif defined(JACKBRIDGE_DIRECT)

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

  1529. #else

  1530.     if (bridge.get_all_properties_ptr != nullptr)

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

  1532. #endif

  1533.     return false;

  1534. }

  1535. 

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

  1537. {

  1538. #if defined(JACKBRIDGE_DUMMY)

  1539. #elif defined(JACKBRIDGE_DIRECT)

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

  1541. #else

  1542.     if (bridge.remove_property_ptr != nullptr)

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

  1544. #endif

  1545.     return false;

  1546. }

  1547. 

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

  1549. {

  1550. #if defined(JACKBRIDGE_DUMMY)

  1551. #elif defined(JACKBRIDGE_DIRECT)

  1552.     return jack_remove_properties(client, subject);

  1553. #else

  1554.     if (bridge.remove_properties_ptr != nullptr)

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

  1556. #endif

  1557.     return 0;

  1558. }

  1559. 

  1560. bool jackbridge_remove_all_properties(jack_client_t* client)

  1561. {

  1562. #if defined(JACKBRIDGE_DUMMY)

  1563. #elif defined(JACKBRIDGE_DIRECT)

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

  1565. #else

  1566.     if (bridge.remove_all_properties_ptr != nullptr)

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

  1568. #endif

  1569.     return false;

  1570. }

  1571. 

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

  1573. {

  1574. #if defined(JACKBRIDGE_DUMMY)

  1575. #elif defined(JACKBRIDGE_DIRECT)

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

  1577. #else

  1578.     if (bridge.set_property_change_callback_ptr != nullptr)

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

  1580. #endif

  1581.     return false;

  1582. }

  1583. 

  1584. // -----------------------------------------------------------------------------