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

1598 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 const JackBridge bridge;

  488. 

  489. #endif // ! JACKBRIDGE_DIRECT

  490. 

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

  492. 

  493. bool jackbridge_is_ok() noexcept

  494. {

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

  496.     return true;

  497. #else

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

  499. #endif

  500. }

  501. 

  502. // -----------------------------------------------------------------------------

  503. 

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

  505. {

  506. #if defined(JACKBRIDGE_DUMMY)

  507. #elif defined(JACKBRIDGE_DIRECT)

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

  509. #else

  510.     if (bridge.get_version_ptr != nullptr)

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

  512. #endif

  513.     if (major_ptr != nullptr)

  514.         *major_ptr = 0;

  515.     if (minor_ptr != nullptr)

  516.         *minor_ptr = 0;

  517.     if (micro_ptr != nullptr)

  518.         *micro_ptr = 0;

  519.     if (proto_ptr != nullptr)

  520.         *proto_ptr = 0;

  521. }

  522. 

  523. const char* jackbridge_get_version_string()

  524. {

  525. #if defined(JACKBRIDGE_DUMMY)

  526. #elif defined(JACKBRIDGE_DIRECT)

  527.     return jack_get_version_string();

  528. #else

  529.     if (bridge.get_version_string_ptr != nullptr)

  530.         return bridge.get_version_string_ptr();

  531. #endif

  532.     return nullptr;

  533. }

  534. 

  535. // -----------------------------------------------------------------------------

  536. 

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

  538. {

  539. #if defined(JACKBRIDGE_DUMMY)

  540. #elif defined(JACKBRIDGE_DIRECT)

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

  542. #else

  543.     if (bridge.client_open_ptr != nullptr)

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

  545. #endif

  546.     if (status != nullptr)

  547.         *status = JackServerError;

  548.     return nullptr;

  549. }

  550. 

  551. bool jackbridge_client_close(jack_client_t* client)

  552. {

  553. #if defined(JACKBRIDGE_DUMMY)

  554. #elif defined(JACKBRIDGE_DIRECT)

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

  556. #else

  557.     if (bridge.client_close_ptr != nullptr)

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

  559. #endif

  560.     return false;

  561. }

  562. 

  563. // -----------------------------------------------------------------------------

  564. 

  565. int jackbridge_client_name_size()

  566. {

  567. #if defined(JACKBRIDGE_DUMMY)

  568. #elif defined(JACKBRIDGE_DIRECT)

  569.     return jack_client_name_size();

  570. #else

  571.     if (bridge.client_name_size_ptr != nullptr)

  572.         return bridge.client_name_size_ptr();

  573. #endif

  574.     return 0;

  575. }

  576. 

  577. char* jackbridge_get_client_name(jack_client_t* client)

  578. {

  579. #if defined(JACKBRIDGE_DUMMY)

  580. #elif defined(JACKBRIDGE_DIRECT)

  581.     return jack_get_client_name(client);

  582. #else

  583.     if (bridge.get_client_name_ptr != nullptr)

  584.         return bridge.get_client_name_ptr(client);

  585. #endif

  586.     return nullptr;

  587. }

  588. 

  589. // -----------------------------------------------------------------------------

  590. 

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

  592. {

  593. #if defined(JACKBRIDGE_DUMMY)

  594. #elif defined(JACKBRIDGE_DIRECT)

  595.     return jack_get_uuid_for_client_name(client, name);

  596. #else

  597.     if (bridge.get_uuid_for_client_name_ptr != nullptr)

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

  599. #endif

  600.     return nullptr;

  601. }

  602. 

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

  604. {

  605. #if defined(JACKBRIDGE_DUMMY)

  606. #elif defined(JACKBRIDGE_DIRECT)

  607.     return jack_get_client_name_by_uuid(client, uuid);

  608. #else

  609.     if (bridge.get_client_name_by_uuid_ptr != nullptr)

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

  611. #endif

  612.     return nullptr;

  613. }

  614. 

  615. // -----------------------------------------------------------------------------

  616. 

  617. bool jackbridge_activate(jack_client_t* client)

  618. {

  619. #if defined(JACKBRIDGE_DUMMY)

  620. #elif defined(JACKBRIDGE_DIRECT)

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

  622. #else

  623.     if (bridge.activate_ptr != nullptr)

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

  625. #endif

  626.     return false;

  627. }

  628. 

  629. bool jackbridge_deactivate(jack_client_t* client)

  630. {

  631. #if defined(JACKBRIDGE_DUMMY)

  632. #elif defined(JACKBRIDGE_DIRECT)

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

  634. #else

  635.     if (bridge.deactivate_ptr != nullptr)

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

  637. #endif

  638.     return false;

  639. }

  640. 

  641. bool jackbridge_is_realtime(jack_client_t* client)

  642. {

  643. #if defined(JACKBRIDGE_DUMMY)

  644. #elif defined(JACKBRIDGE_DIRECT)

  645.     return jack_is_realtime(client);

  646. #else

  647.     if (bridge.is_realtime_ptr != nullptr)

  648.         return bridge.is_realtime_ptr(client);

  649. #endif

  650.     return false;

  651. }

  652. 

  653. // -----------------------------------------------------------------------------

  654. 

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

  656. {

  657. #if defined(JACKBRIDGE_DUMMY)

  658. #elif defined(JACKBRIDGE_DIRECT)

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

  660. #else

  661.     if (bridge.set_thread_init_callback_ptr != nullptr)

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

  663. #endif

  664.     return false;

  665. }

  666. 

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

  668. {

  669. #if defined(JACKBRIDGE_DUMMY)

  670. #elif defined(JACKBRIDGE_DIRECT)

  671.     jack_on_shutdown(client, shutdown_callback, arg);

  672. #else

  673.     if (bridge.on_shutdown_ptr != nullptr)

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

  675. #endif

  676. }

  677. 

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

  679. {

  680. #if defined(JACKBRIDGE_DUMMY)

  681. #elif defined(JACKBRIDGE_DIRECT)

  682.     jack_on_info_shutdown(client, shutdown_callback, arg);

  683. #else

  684.     if (bridge.on_info_shutdown_ptr != nullptr)

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

  686. #endif

  687. }

  688. 

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

  690. {

  691. #if defined(JACKBRIDGE_DUMMY)

  692. #elif defined(JACKBRIDGE_DIRECT)

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

  694. #else

  695.     if (bridge.set_process_callback_ptr != nullptr)

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

  697. #endif

  698.     return false;

  699. }

  700. 

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

  702. {

  703. #if defined(JACKBRIDGE_DUMMY)

  704. #elif defined(JACKBRIDGE_DIRECT)

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

  706. #else

  707.     if (bridge.set_freewheel_callback_ptr != nullptr)

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

  709. #endif

  710.     return false;

  711. }

  712. 

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

  714. {

  715. #if defined(JACKBRIDGE_DUMMY)

  716. #elif defined(JACKBRIDGE_DIRECT)

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

  718. #else

  719.     if (bridge.set_buffer_size_callback_ptr != nullptr)

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

  721. #endif

  722.     return false;

  723. }

  724. 

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

  726. {

  727. #if defined(JACKBRIDGE_DUMMY)

  728. #elif defined(JACKBRIDGE_DIRECT)

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

  730. #else

  731.     if (bridge.set_sample_rate_callback_ptr != nullptr)

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

  733. #endif

  734.     return false;

  735. }

  736. 

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

  738. {

  739. #if defined(JACKBRIDGE_DUMMY)

  740. #elif defined(JACKBRIDGE_DIRECT)

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

  742. #else

  743.     if (bridge.set_client_registration_callback_ptr != nullptr)

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

  745. #endif

  746.     return false;

  747. }

  748. 

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

  750. {

  751. #if defined(JACKBRIDGE_DUMMY)

  752. #elif defined(JACKBRIDGE_DIRECT)

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

  754. #else

  755.     if (bridge.set_port_registration_callback_ptr != nullptr)

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

  757. #endif

  758.     return false;

  759. }

  760. 

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

  762. {

  763. #if defined(JACKBRIDGE_DUMMY)

  764. #elif defined(JACKBRIDGE_DIRECT)

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

  766. #else

  767.     if (bridge.set_port_rename_callback_ptr != nullptr)

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

  769. #endif

  770.     return false;

  771. }

  772. 

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

  774. {

  775. #if defined(JACKBRIDGE_DUMMY)

  776. #elif defined(JACKBRIDGE_DIRECT)

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

  778. #else

  779.     if (bridge.set_port_connect_callback_ptr != nullptr)

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

  781. #endif

  782.     return false;

  783. }

  784. 

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

  786. {

  787. #if defined(JACKBRIDGE_DUMMY)

  788. #elif defined(JACKBRIDGE_DIRECT)

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

  790. #else

  791.     if (bridge.set_xrun_callback_ptr != nullptr)

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

  793. #endif

  794.     return false;

  795. }

  796. 

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

  798. {

  799. #if defined(JACKBRIDGE_DUMMY)

  800. #elif defined(JACKBRIDGE_DIRECT)

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

  802. #else

  803.     if (bridge.set_latency_callback_ptr != nullptr)

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

  805. #endif

  806.     return false;

  807. }

  808. 

  809. // -----------------------------------------------------------------------------

  810. 

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

  812. {

  813. #if defined(JACKBRIDGE_DUMMY)

  814. #elif defined(JACKBRIDGE_DIRECT)

  815.     return jack_set_freewheel(client, onoff);

  816. #else

  817.     if (bridge.set_freewheel_ptr != nullptr)

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

  819. #endif

  820.     return false;

  821. }

  822. 

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

  824. {

  825. #if defined(JACKBRIDGE_DUMMY)

  826. #elif defined(JACKBRIDGE_DIRECT)

  827.     return jack_set_buffer_size(client, nframes);

  828. #else

  829.     if (bridge.set_buffer_size_ptr != nullptr)

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

  831. #endif

  832.     return false;

  833. }

  834. 

  835. // -----------------------------------------------------------------------------

  836. 

  837. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  838. {

  839. #if defined(JACKBRIDGE_DUMMY)

  840. #elif defined(JACKBRIDGE_DIRECT)

  841.     return jack_get_sample_rate(client);

  842. #else

  843.     if (bridge.get_sample_rate_ptr != nullptr)

  844.         return bridge.get_sample_rate_ptr(client);

  845. #endif

  846.     return 0;

  847. }

  848. 

  849. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  850. {

  851. #if defined(JACKBRIDGE_DUMMY)

  852. #elif defined(JACKBRIDGE_DIRECT)

  853.     return jack_get_buffer_size(client);

  854. #else

  855.     if (bridge.get_buffer_size_ptr != nullptr)

  856.         return bridge.get_buffer_size_ptr(client);

  857. #endif

  858.     return 0;

  859. }

  860. 

  861. float jackbridge_cpu_load(jack_client_t* client)

  862. {

  863. #if defined(JACKBRIDGE_DUMMY)

  864. #elif defined(JACKBRIDGE_DIRECT)

  865.     return jack_cpu_load(client);

  866. #else

  867.     if (bridge.cpu_load_ptr != nullptr)

  868.         return bridge.cpu_load_ptr(client);

  869. #endif

  870.     return 0.0f;

  871. }

  872. 

  873. // -----------------------------------------------------------------------------

  874. 

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

  876. {

  877. #if defined(JACKBRIDGE_DUMMY)

  878. #elif defined(JACKBRIDGE_DIRECT)

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

  880. #else

  881.     if (bridge.port_register_ptr != nullptr)

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

  883. #endif

  884.     return nullptr;

  885. }

  886. 

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

  888. {

  889. #if defined(JACKBRIDGE_DUMMY)

  890. #elif defined(JACKBRIDGE_DIRECT)

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

  892. #else

  893.     if (bridge.port_unregister_ptr != nullptr)

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

  895. #endif

  896.     return false;

  897. }

  898. 

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

  900. {

  901. #if defined(JACKBRIDGE_DUMMY)

  902. #elif defined(JACKBRIDGE_DIRECT)

  903.     return jack_port_get_buffer(port, nframes);

  904. #else

  905.     if (bridge.port_get_buffer_ptr != nullptr)

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

  907. #endif

  908.     return nullptr;

  909. }

  910. 

  911. // -----------------------------------------------------------------------------

  912. 

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

  914. {

  915. #if defined(JACKBRIDGE_DUMMY)

  916. #elif defined(JACKBRIDGE_DIRECT)

  917.     return jack_port_name(port);

  918. #else

  919.     if (bridge.port_name_ptr != nullptr)

  920.         return bridge.port_name_ptr(port);

  921. #endif

  922.     return nullptr;

  923. }

  924. 

  925. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  926. {

  927. #if defined(JACKBRIDGE_DUMMY)

  928. #elif defined(JACKBRIDGE_DIRECT)

  929.     return jack_port_uuid(port);

  930. #else

  931.     if (bridge.port_uuid_ptr != nullptr)

  932.         return bridge.port_uuid_ptr(port);

  933. #endif

  934.     return 0;

  935. }

  936. 

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

  938. {

  939. #if defined(JACKBRIDGE_DUMMY)

  940. #elif defined(JACKBRIDGE_DIRECT)

  941.     return jack_port_short_name(port);

  942. #else

  943.     if (bridge.port_short_name_ptr != nullptr)

  944.         return bridge.port_short_name_ptr(port);

  945. #endif

  946.     return nullptr;

  947. }

  948. 

  949. int jackbridge_port_flags(const jack_port_t* port)

  950. {

  951. #if defined(JACKBRIDGE_DUMMY)

  952. #elif defined(JACKBRIDGE_DIRECT)

  953.     return jack_port_flags(port);

  954. #else

  955.     if (bridge.port_flags_ptr != nullptr)

  956.         return bridge.port_flags_ptr(port);

  957. #endif

  958.     return 0x0;

  959. }

  960. 

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

  962. {

  963. #if defined(JACKBRIDGE_DUMMY)

  964. #elif defined(JACKBRIDGE_DIRECT)

  965.     return jack_port_type(port);

  966. #else

  967.     if (bridge.port_type_ptr != nullptr)

  968.         return bridge.port_type_ptr(port);

  969. #endif

  970.     return nullptr;

  971. }

  972. 

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

  974. {

  975. #if defined(JACKBRIDGE_DUMMY)

  976. #elif defined(JACKBRIDGE_DIRECT)

  977.     return jack_port_is_mine(client, port);

  978. #else

  979.     if (bridge.port_is_mine_ptr != nullptr)

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

  981. #endif

  982.     return false;

  983. }

  984. 

  985. int jackbridge_port_connected(const jack_port_t* port)

  986. {

  987. #if defined(JACKBRIDGE_DUMMY)

  988. #elif defined(JACKBRIDGE_DIRECT)

  989.     return jack_port_connected(port);

  990. #else

  991.     if (bridge.port_connected_ptr != nullptr)

  992.         return bridge.port_connected_ptr(port);

  993. #endif

  994.     return 0;

  995. }

  996. 

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

  998. {

  999. #if defined(JACKBRIDGE_DUMMY)

  1000. #elif defined(JACKBRIDGE_DIRECT)

  1001.     return jack_port_connected_to(port, port_name);

  1002. #else

  1003.     if (bridge.port_connected_to_ptr != nullptr)

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

  1005. #endif

  1006.     return false;

  1007. }

  1008. 

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

  1010. {

  1011. #if defined(JACKBRIDGE_DUMMY)

  1012. #elif defined(JACKBRIDGE_DIRECT)

  1013.     return jack_port_get_connections(port);

  1014. #else

  1015.     if (bridge.port_get_connections_ptr != nullptr)

  1016.         return bridge.port_get_connections_ptr(port);

  1017. #endif

  1018.     return nullptr;

  1019. }

  1020. 

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

  1022. {

  1023. #if defined(JACKBRIDGE_DUMMY)

  1024. #elif defined(JACKBRIDGE_DIRECT)

  1025.     return jack_port_get_all_connections(client, port);

  1026. #else

  1027.     if (bridge.port_get_all_connections_ptr != nullptr)

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

  1029. #endif

  1030.     return nullptr;

  1031. }

  1032. 

  1033. // -----------------------------------------------------------------------------

  1034. 

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

  1036. {

  1037. #if defined(JACKBRIDGE_DUMMY)

  1038. #elif defined(JACKBRIDGE_DIRECT)

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

  1040. #else

  1041.     if (bridge.port_set_name_ptr != nullptr)

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

  1043. #endif

  1044.     return false;

  1045. }

  1046. 

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

  1048. {

  1049. #if defined(JACKBRIDGE_DUMMY)

  1050. #elif defined(JACKBRIDGE_DIRECT)

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

  1052. #else

  1053.     if (bridge.port_set_alias_ptr != nullptr)

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

  1055. #endif

  1056.     return false;

  1057. }

  1058. 

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

  1060. {

  1061. #if defined(JACKBRIDGE_DUMMY)

  1062. #elif defined(JACKBRIDGE_DIRECT)

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

  1064. #else

  1065.     if (bridge.port_unset_alias_ptr != nullptr)

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

  1067. #endif

  1068.     return false;

  1069. }

  1070. 

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

  1072. {

  1073. #if defined(JACKBRIDGE_DUMMY)

  1074. #elif defined(JACKBRIDGE_DIRECT)

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

  1076. #else

  1077.     if (bridge.port_get_aliases_ptr != nullptr)

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

  1079. #endif

  1080.     return 0;

  1081. }

  1082. 

  1083. // -----------------------------------------------------------------------------

  1084. 

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

  1086. {

  1087. #if defined(JACKBRIDGE_DUMMY)

  1088. #elif defined(JACKBRIDGE_DIRECT)

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

  1090. #else

  1091.     if (bridge.port_request_monitor_ptr != nullptr)

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

  1093. #endif

  1094.     return false;

  1095. }

  1096. 

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

  1098. {

  1099. #if defined(JACKBRIDGE_DUMMY)

  1100. #elif defined(JACKBRIDGE_DIRECT)

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

  1102. #else

  1103.     if (bridge.port_request_monitor_by_name_ptr != nullptr)

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

  1105. #endif

  1106.     return false;

  1107. }

  1108. 

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

  1110. {

  1111. #if defined(JACKBRIDGE_DUMMY)

  1112. #elif defined(JACKBRIDGE_DIRECT)

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

  1114. #else

  1115.     if (bridge.port_ensure_monitor_ptr != nullptr)

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

  1117. #endif

  1118.     return false;

  1119. }

  1120. 

  1121. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1122. {

  1123. #if defined(JACKBRIDGE_DUMMY)

  1124. #elif defined(JACKBRIDGE_DIRECT)

  1125.     return jack_port_monitoring_input(port);

  1126. #else

  1127.     if (bridge.port_monitoring_input_ptr != nullptr)

  1128.         return bridge.port_monitoring_input_ptr(port);

  1129. #endif

  1130.     return false;

  1131. }

  1132. 

  1133. // -----------------------------------------------------------------------------

  1134. 

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

  1136. {

  1137. #if defined(JACKBRIDGE_DUMMY)

  1138. #elif defined(JACKBRIDGE_DIRECT)

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

  1140. #else

  1141.     if (bridge.connect_ptr != nullptr)

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

  1143. #endif

  1144.     return false;

  1145. }

  1146. 

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

  1148. {

  1149. #if defined(JACKBRIDGE_DUMMY)

  1150. #elif defined(JACKBRIDGE_DIRECT)

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

  1152. #else

  1153.     if (bridge.disconnect_ptr != nullptr)

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

  1155. #endif

  1156.     return false;

  1157. }

  1158. 

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

  1160. {

  1161. #if defined(JACKBRIDGE_DUMMY)

  1162. #elif defined(JACKBRIDGE_DIRECT)

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

  1164. #else

  1165.     if (bridge.port_disconnect_ptr != nullptr)

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

  1167. #endif

  1168.     return false;

  1169. }

  1170. 

  1171. // -----------------------------------------------------------------------------

  1172. 

  1173. int jackbridge_port_name_size()

  1174. {

  1175. #if defined(JACKBRIDGE_DUMMY)

  1176. #elif defined(JACKBRIDGE_DIRECT)

  1177.     return jack_port_name_size();

  1178. #else

  1179.     if (bridge.port_name_size_ptr != nullptr)

  1180.         return bridge.port_name_size_ptr();

  1181. #endif

  1182.     return 0;

  1183. }

  1184. 

  1185. int jackbridge_port_type_size()

  1186. {

  1187. #if defined(JACKBRIDGE_DUMMY)

  1188. #elif defined(JACKBRIDGE_DIRECT)

  1189.     return jack_port_type_size();

  1190. #else

  1191.     if (bridge.port_type_size_ptr != nullptr)

  1192.         return bridge.port_type_size_ptr();

  1193. #endif

  1194.     return 0;

  1195. }

  1196. 

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

  1198. {

  1199. #if defined(JACKBRIDGE_DUMMY)

  1200. #elif defined(JACKBRIDGE_DIRECT)

  1201.     return jack_port_type_get_buffer_size(client, port_type);

  1202. #else

  1203.     if (bridge.port_type_get_buffer_size_ptr != nullptr)

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

  1205. #endif

  1206.     return 0;

  1207. }

  1208. 

  1209. // -----------------------------------------------------------------------------

  1210. 

  1211. void jackbridge_port_get_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.     return jack_port_get_latency_range(port, mode, range);

  1216. #else

  1217.     if (bridge.port_get_latency_range_ptr != nullptr)

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

  1219. #endif

  1220.     range->min = 0;

  1221.     range->max = 0;

  1222. }

  1223. 

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

  1225. {

  1226. #if defined(JACKBRIDGE_DUMMY)

  1227. #elif defined(JACKBRIDGE_DIRECT)

  1228.     jack_port_set_latency_range(port, mode, range);

  1229. #else

  1230.     if (bridge.port_set_latency_range_ptr != nullptr)

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

  1232. #endif

  1233. }

  1234. 

  1235. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1236. {

  1237. #if defined(JACKBRIDGE_DUMMY)

  1238. #elif defined(JACKBRIDGE_DIRECT)

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

  1240. #else

  1241.     if (bridge.recompute_total_latencies_ptr != nullptr)

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

  1243. #endif

  1244.     return false;

  1245. }

  1246. 

  1247. // -----------------------------------------------------------------------------

  1248. 

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

  1250. {

  1251. #if defined(JACKBRIDGE_DUMMY)

  1252. #elif defined(JACKBRIDGE_DIRECT)

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

  1254. #else

  1255.     if (bridge.get_ports_ptr != nullptr)

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

  1257. #endif

  1258.     return nullptr;

  1259. }

  1260. 

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

  1262. {

  1263. #if defined(JACKBRIDGE_DUMMY)

  1264. #elif defined(JACKBRIDGE_DIRECT)

  1265.     return jack_port_by_name(client, port_name);

  1266. #else

  1267.     if (bridge.port_by_name_ptr != nullptr)

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

  1269. #endif

  1270.     return nullptr;

  1271. }

  1272. 

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

  1274. {

  1275. #if defined(JACKBRIDGE_DUMMY)

  1276. #elif defined(JACKBRIDGE_DIRECT)

  1277.     return jack_port_by_id(client, port_id);

  1278. #else

  1279.     if (bridge.port_by_id_ptr != nullptr)

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

  1281. #endif

  1282.     return nullptr;

  1283. }

  1284. 

  1285. // -----------------------------------------------------------------------------

  1286. 

  1287. void jackbridge_free(void* ptr)

  1288. {

  1289. #if defined(JACKBRIDGE_DUMMY)

  1290. #elif defined(JACKBRIDGE_DIRECT)

  1291.     return jack_free(ptr);

  1292. #else

  1293.     if (bridge.free_ptr != nullptr)

  1294.         return bridge.free_ptr(ptr);

  1295. 

  1296.     // just in case

  1297.     std::free(ptr);

  1298. #endif

  1299. }

  1300. 

  1301. // -----------------------------------------------------------------------------

  1302. 

  1303. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1304. {

  1305. #if defined(JACKBRIDGE_DUMMY)

  1306. #elif defined(JACKBRIDGE_DIRECT)

  1307.     return jack_midi_get_event_count(port_buffer);

  1308. #else

  1309.     if (bridge.midi_get_event_count_ptr != nullptr)

  1310.         return bridge.midi_get_event_count_ptr(port_buffer);

  1311. #endif

  1312.     return 0;

  1313. }

  1314. 

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

  1316. {

  1317. #if defined(JACKBRIDGE_DUMMY)

  1318. #elif defined(JACKBRIDGE_DIRECT)

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

  1320. #else

  1321.     if (bridge.midi_event_get_ptr != nullptr)

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

  1323. #endif

  1324.     return false;

  1325. }

  1326. 

  1327. void jackbridge_midi_clear_buffer(void* port_buffer)

  1328. {

  1329. #if defined(JACKBRIDGE_DUMMY)

  1330. #elif defined(JACKBRIDGE_DIRECT)

  1331.     jack_midi_clear_buffer(port_buffer);

  1332. #else

  1333.     if (bridge.midi_clear_buffer_ptr != nullptr)

  1334.         bridge.midi_clear_buffer_ptr(port_buffer);

  1335. #endif

  1336. }

  1337. 

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

  1339. {

  1340. #if defined(JACKBRIDGE_DUMMY)

  1341. #elif defined(JACKBRIDGE_DIRECT)

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

  1343. #else

  1344.     if (bridge.midi_event_write_ptr != nullptr)

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

  1346. #endif

  1347.     return false;

  1348. }

  1349. 

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

  1351. {

  1352. #if defined(JACKBRIDGE_DUMMY)

  1353. #elif defined(JACKBRIDGE_DIRECT)

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

  1355. #else

  1356.     if (bridge.midi_event_reserve_ptr != nullptr)

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

  1358. #endif

  1359.     return nullptr;

  1360. }

  1361. 

  1362. // -----------------------------------------------------------------------------

  1363. 

  1364. bool jackbridge_release_timebase(jack_client_t* client)

  1365. {

  1366. #if defined(JACKBRIDGE_DUMMY)

  1367. #elif defined(JACKBRIDGE_DIRECT)

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

  1369. #else

  1370.     if (bridge.release_timebase_ptr != nullptr)

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

  1372. #endif

  1373.     return false;

  1374. }

  1375. 

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

  1377. {

  1378. #if defined(JACKBRIDGE_DUMMY)

  1379. #elif defined(JACKBRIDGE_DIRECT)

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

  1381. #else

  1382.     if (bridge.set_sync_callback_ptr != nullptr)

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

  1384. #endif

  1385.     return false;

  1386. }

  1387. 

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

  1389. {

  1390. #if defined(JACKBRIDGE_DUMMY)

  1391. #elif defined(JACKBRIDGE_DIRECT)

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

  1393. #else

  1394.     if (bridge.set_sync_timeout_ptr != nullptr)

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

  1396. #endif

  1397.     return false;

  1398. }

  1399. 

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

  1401. {

  1402. #if defined(JACKBRIDGE_DUMMY)

  1403. #elif defined(JACKBRIDGE_DIRECT)

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

  1405. #else

  1406.     if (bridge.set_timebase_callback_ptr != nullptr)

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

  1408. #endif

  1409.     return false;

  1410. }

  1411. 

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

  1413. {

  1414. #if defined(JACKBRIDGE_DUMMY)

  1415. #elif defined(JACKBRIDGE_DIRECT)

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

  1417. #else

  1418.     if (bridge.transport_locate_ptr != nullptr)

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

  1420. #endif

  1421.     return false;

  1422. }

  1423. 

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

  1425. {

  1426. #if defined(JACKBRIDGE_DUMMY)

  1427. #elif defined(JACKBRIDGE_DIRECT)

  1428.     return jack_transport_query(client, pos);

  1429. #else

  1430.     if (bridge.transport_query_ptr != nullptr)

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

  1432. #endif

  1433.     if (pos != nullptr)

  1434.     {

  1435.         // invalidate

  1436.         pos->unique_1 = 0;

  1437.         pos->unique_2 = 1;

  1438.     }

  1439.     return JackTransportStopped;

  1440. }

  1441. 

  1442. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1443. {

  1444. #if defined(JACKBRIDGE_DUMMY)

  1445. #elif defined(JACKBRIDGE_DIRECT)

  1446.     return jack_get_current_transport_frame(client);

  1447. #else

  1448.     if (bridge.get_current_transport_frame_ptr != nullptr)

  1449.         return bridge.get_current_transport_frame_ptr(client);

  1450. #endif

  1451.     return 0;

  1452. }

  1453. 

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

  1455. {

  1456. #if defined(JACKBRIDGE_DUMMY)

  1457. #elif defined(JACKBRIDGE_DIRECT)

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

  1459. #else

  1460.     if (bridge.transport_reposition_ptr != nullptr)

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

  1462. #endif

  1463.     return false;

  1464. }

  1465. 

  1466. void jackbridge_transport_start(jack_client_t* client)

  1467. {

  1468. #if defined(JACKBRIDGE_DUMMY)

  1469. #elif defined(JACKBRIDGE_DIRECT)

  1470.     jack_transport_start(client);

  1471. #else

  1472.     if (bridge.transport_start_ptr != nullptr)

  1473.         bridge.transport_start_ptr(client);

  1474. #endif

  1475. }

  1476. 

  1477. void jackbridge_transport_stop(jack_client_t* client)

  1478. {

  1479. #if defined(JACKBRIDGE_DUMMY)

  1480. #elif defined(JACKBRIDGE_DIRECT)

  1481.     jack_transport_stop(client);

  1482. #else

  1483.     if (bridge.transport_stop_ptr != nullptr)

  1484.         bridge.transport_stop_ptr(client);

  1485. #endif

  1486. }

  1487. 

  1488. // -----------------------------------------------------------------------------

  1489. 

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

  1491. {

  1492. #if defined(JACKBRIDGE_DUMMY)

  1493. #elif defined(JACKBRIDGE_DIRECT)

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

  1495. #else

  1496.     if (bridge.set_property_ptr != nullptr)

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

  1498. #endif

  1499.     return false;

  1500. }

  1501. 

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

  1503. {

  1504. #if defined(JACKBRIDGE_DUMMY)

  1505. #elif defined(JACKBRIDGE_DIRECT)

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

  1507. #else

  1508.     if (bridge.get_property_ptr != nullptr)

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

  1510. #endif

  1511.     return false;

  1512. }

  1513. 

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

  1515. {

  1516. #if defined(JACKBRIDGE_DUMMY)

  1517. #elif defined(JACKBRIDGE_DIRECT)

  1518.     jack_free_description(desc, free_description_itself);

  1519. #else

  1520.     if (bridge.free_description_ptr != nullptr)

  1521.         bridge.free_description_ptr(desc, free_description_itself);

  1522. #endif

  1523. }

  1524. 

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

  1526. {

  1527. #if defined(JACKBRIDGE_DUMMY)

  1528. #elif defined(JACKBRIDGE_DIRECT)

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

  1530. #else

  1531.     if (bridge.get_properties_ptr != nullptr)

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

  1533. #endif

  1534.     return false;

  1535. }

  1536. 

  1537. bool jackbridge_get_all_properties(jack_description_t** descs)

  1538. {

  1539. #if defined(JACKBRIDGE_DUMMY)

  1540. #elif defined(JACKBRIDGE_DIRECT)

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

  1542. #else

  1543.     if (bridge.get_all_properties_ptr != nullptr)

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

  1545. #endif

  1546.     return false;

  1547. }

  1548. 

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

  1550. {

  1551. #if defined(JACKBRIDGE_DUMMY)

  1552. #elif defined(JACKBRIDGE_DIRECT)

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

  1554. #else

  1555.     if (bridge.remove_property_ptr != nullptr)

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

  1557. #endif

  1558.     return false;

  1559. }

  1560. 

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

  1562. {

  1563. #if defined(JACKBRIDGE_DUMMY)

  1564. #elif defined(JACKBRIDGE_DIRECT)

  1565.     return jack_remove_properties(client, subject);

  1566. #else

  1567.     if (bridge.remove_properties_ptr != nullptr)

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

  1569. #endif

  1570.     return 0;

  1571. }

  1572. 

  1573. bool jackbridge_remove_all_properties(jack_client_t* client)

  1574. {

  1575. #if defined(JACKBRIDGE_DUMMY)

  1576. #elif defined(JACKBRIDGE_DIRECT)

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

  1578. #else

  1579.     if (bridge.remove_all_properties_ptr != nullptr)

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

  1581. #endif

  1582.     return false;

  1583. }

  1584. 

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

  1586. {

  1587. #if defined(JACKBRIDGE_DUMMY)

  1588. #elif defined(JACKBRIDGE_DIRECT)

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

  1590. #else

  1591.     if (bridge.set_property_change_callback_ptr != nullptr)

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

  1593. #endif

  1594.     return false;

  1595. }

  1596. 

  1597. // -----------------------------------------------------------------------------