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

1633 lines
56KB
Raw Blame History 

  1. /*

  2.  * JackBridge (Part 1, JACK functions)

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

  4.  *

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

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

  7.  * permission notice appear in all copies.

  8.  *

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

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

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

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

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

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

  15.  */

  16. 

  17. #include "JackBridge.hpp"

  18. 

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

  20. 

  21. #include "CarlaLibUtils.hpp"

  22. 

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

  24. 

  25. extern "C" {

  26. 

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

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

  29. 

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

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

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

  33. 

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

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

  36. 

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

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

  39. 

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

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

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

  43. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  58. 

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

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

  61. 

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

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

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

  65. 

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

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

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

  69. 

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

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

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

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

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

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

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

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

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

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

  80. 

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

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

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

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

  85. 

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

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

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

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

  90. 

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

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

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

  94. 

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

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

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

  98. 

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

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

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

  102. 

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

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

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

  106. 

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

  108. 

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

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

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

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

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

  114. 

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

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

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

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

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

  120. 

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

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

  123. 

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

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

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

  127. 

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

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

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

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

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

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

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

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

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

  137. 

  138. } // extern "C"

  139. 

  140. // -----------------------------------------------------------------------------

  141. 

  142. struct JackBridge {

  143.     void* lib;

  144. 

  145.     jacksym_get_version get_version_ptr;

  146.     jacksym_get_version_string get_version_string_ptr;

  147. 

  148.     jacksym_client_open client_open_ptr;

  149.     jacksym_client_rename client_rename_ptr;

  150.     jacksym_client_close client_close_ptr;

  151. 

  152.     jacksym_client_name_size client_name_size_ptr;

  153.     jacksym_get_client_name get_client_name_ptr;

  154. 

  155.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  156.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  157. 

  158.     jacksym_activate activate_ptr;

  159.     jacksym_deactivate deactivate_ptr;

  160.     jacksym_is_realtime is_realtime_ptr;

  161. 

  162.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  163.     jacksym_on_shutdown on_shutdown_ptr;

  164.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  165.     jacksym_set_process_callback set_process_callback_ptr;

  166.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  167.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  168.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  169.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  170.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  171.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  172.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  173.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  174.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  175.     jacksym_set_latency_callback set_latency_callback_ptr;

  176. 

  177.     jacksym_set_freewheel set_freewheel_ptr;

  178.     jacksym_set_buffer_size set_buffer_size_ptr;

  179. 

  180.     jacksym_get_sample_rate get_sample_rate_ptr;

  181.     jacksym_get_buffer_size get_buffer_size_ptr;

  182.     jacksym_cpu_load cpu_load_ptr;

  183. 

  184.     jacksym_port_register port_register_ptr;

  185.     jacksym_port_unregister port_unregister_ptr;

  186.     jacksym_port_get_buffer port_get_buffer_ptr;

  187. 

  188.     jacksym_port_name port_name_ptr;

  189.     jacksym_port_uuid port_uuid_ptr;

  190.     jacksym_port_short_name port_short_name_ptr;

  191.     jacksym_port_flags port_flags_ptr;

  192.     jacksym_port_type port_type_ptr;

  193.     jacksym_port_is_mine port_is_mine_ptr;

  194.     jacksym_port_connected port_connected_ptr;

  195.     jacksym_port_connected_to port_connected_to_ptr;

  196.     jacksym_port_get_connections port_get_connections_ptr;

  197.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  198. 

  199.     jacksym_port_set_name port_set_name_ptr;

  200.     jacksym_port_set_alias port_set_alias_ptr;

  201.     jacksym_port_unset_alias port_unset_alias_ptr;

  202.     jacksym_port_get_aliases port_get_aliases_ptr;

  203. 

  204.     jacksym_port_request_monitor port_request_monitor_ptr;

  205.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  206.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  207.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  208. 

  209.     jacksym_connect connect_ptr;

  210.     jacksym_disconnect disconnect_ptr;

  211.     jacksym_port_disconnect port_disconnect_ptr;

  212. 

  213.     jacksym_port_name_size port_name_size_ptr;

  214.     jacksym_port_type_size port_type_size_ptr;

  215.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  216. 

  217.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  218.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  219.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  220. 

  221.     jacksym_get_ports get_ports_ptr;

  222.     jacksym_port_by_name port_by_name_ptr;

  223.     jacksym_port_by_id port_by_id_ptr;

  224. 

  225.     jacksym_free free_ptr;

  226. 

  227.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  228.     jacksym_midi_event_get midi_event_get_ptr;

  229.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  230.     jacksym_midi_event_write midi_event_write_ptr;

  231.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  232. 

  233.     jacksym_release_timebase release_timebase_ptr;

  234.     jacksym_set_sync_callback set_sync_callback_ptr;

  235.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  236.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  237.     jacksym_transport_locate transport_locate_ptr;

  238. 

  239.     jacksym_transport_query transport_query_ptr;

  240.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  241. 

  242.     jacksym_transport_reposition transport_reposition_ptr;

  243.     jacksym_transport_start transport_start_ptr;

  244.     jacksym_transport_stop transport_stop_ptr;

  245. 

  246.     jacksym_set_property set_property_ptr;

  247.     jacksym_get_property get_property_ptr;

  248.     jacksym_free_description free_description_ptr;

  249.     jacksym_get_properties get_properties_ptr;

  250.     jacksym_get_all_properties get_all_properties_ptr;

  251.     jacksym_remove_property remove_property_ptr;

  252.     jacksym_remove_properties remove_properties_ptr;

  253.     jacksym_remove_all_properties remove_all_properties_ptr;

  254.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  255. 

  256.     JackBridge()

  257.         : lib(nullptr),

  258.           get_version_ptr(nullptr),

  259.           get_version_string_ptr(nullptr),

  260.           client_open_ptr(nullptr),

  261.           client_rename_ptr(nullptr),

  262.           client_close_ptr(nullptr),

  263.           client_name_size_ptr(nullptr),

  264.           get_client_name_ptr(nullptr),

  265.           get_uuid_for_client_name_ptr(nullptr),

  266.           get_client_name_by_uuid_ptr(nullptr),

  267.           activate_ptr(nullptr),

  268.           deactivate_ptr(nullptr),

  269.           is_realtime_ptr(nullptr),

  270.           set_thread_init_callback_ptr(nullptr),

  271.           on_shutdown_ptr(nullptr),

  272.           on_info_shutdown_ptr(nullptr),

  273.           set_process_callback_ptr(nullptr),

  274.           set_freewheel_callback_ptr(nullptr),

  275.           set_buffer_size_callback_ptr(nullptr),

  276.           set_sample_rate_callback_ptr(nullptr),

  277.           set_client_registration_callback_ptr(nullptr),

  278.           set_port_registration_callback_ptr(nullptr),

  279.           set_port_rename_callback_ptr(nullptr),

  280.           set_port_connect_callback_ptr(nullptr),

  281.           set_graph_order_callback_ptr(nullptr),

  282.           set_xrun_callback_ptr(nullptr),

  283.           set_latency_callback_ptr(nullptr),

  284.           set_freewheel_ptr(nullptr),

  285.           set_buffer_size_ptr(nullptr),

  286.           get_sample_rate_ptr(nullptr),

  287.           get_buffer_size_ptr(nullptr),

  288.           cpu_load_ptr(nullptr),

  289.           port_register_ptr(nullptr),

  290.           port_unregister_ptr(nullptr),

  291.           port_get_buffer_ptr(nullptr),

  292.           port_name_ptr(nullptr),

  293.           port_uuid_ptr(nullptr),

  294.           port_short_name_ptr(nullptr),

  295.           port_flags_ptr(nullptr),

  296.           port_type_ptr(nullptr),

  297.           port_is_mine_ptr(nullptr),

  298.           port_connected_ptr(nullptr),

  299.           port_connected_to_ptr(nullptr),

  300.           port_get_connections_ptr(nullptr),

  301.           port_get_all_connections_ptr(nullptr),

  302.           port_set_name_ptr(nullptr),

  303.           port_set_alias_ptr(nullptr),

  304.           port_unset_alias_ptr(nullptr),

  305.           port_get_aliases_ptr(nullptr),

  306.           port_request_monitor_ptr(nullptr),

  307.           port_request_monitor_by_name_ptr(nullptr),

  308.           port_ensure_monitor_ptr(nullptr),

  309.           port_monitoring_input_ptr(nullptr),

  310.           connect_ptr(nullptr),

  311.           disconnect_ptr(nullptr),

  312.           port_disconnect_ptr(nullptr),

  313.           port_name_size_ptr(nullptr),

  314.           port_type_size_ptr(nullptr),

  315.           port_type_get_buffer_size_ptr(nullptr),

  316.           port_get_latency_range_ptr(nullptr),

  317.           port_set_latency_range_ptr(nullptr),

  318.           recompute_total_latencies_ptr(nullptr),

  319.           get_ports_ptr(nullptr),

  320.           port_by_name_ptr(nullptr),

  321.           port_by_id_ptr(nullptr),

  322.           free_ptr(nullptr),

  323.           midi_get_event_count_ptr(nullptr),

  324.           midi_event_get_ptr(nullptr),

  325.           midi_clear_buffer_ptr(nullptr),

  326.           midi_event_write_ptr(nullptr),

  327.           midi_event_reserve_ptr(nullptr),

  328.           release_timebase_ptr(nullptr),

  329.           set_sync_callback_ptr(nullptr),

  330.           set_sync_timeout_ptr(nullptr),

  331.           set_timebase_callback_ptr(nullptr),

  332.           transport_locate_ptr(nullptr),

  333.           transport_query_ptr(nullptr),

  334.           get_current_transport_frame_ptr(nullptr),

  335.           transport_reposition_ptr(nullptr),

  336.           transport_start_ptr(nullptr),

  337.           transport_stop_ptr(nullptr),

  338.           set_property_ptr(nullptr),

  339.           get_property_ptr(nullptr),

  340.           free_description_ptr(nullptr),

  341.           get_properties_ptr(nullptr),

  342.           get_all_properties_ptr(nullptr),

  343.           remove_property_ptr(nullptr),

  344.           remove_properties_ptr(nullptr),

  345.           remove_all_properties_ptr(nullptr),

  346.           set_property_change_callback_ptr(nullptr)

  347.     {

  348. # if defined(CARLA_OS_MAC)

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

  350. # elif defined(CARLA_OS_WIN)

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

  352. # else

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

  354. # endif

  355. 

  356.         lib = lib_open(filename);

  357. 

  358.         if (lib == nullptr)

  359.         {

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

  361.             return;

  362.         }

  363.         else

  364.         {

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

  366.         }

  367. 

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

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

  370. 

  371.         LIB_SYMBOL(get_version)

  372.         LIB_SYMBOL(get_version_string)

  373. 

  374.         LIB_SYMBOL(client_open)

  375.         LIB_SYMBOL(client_rename)

  376.         LIB_SYMBOL(client_close)

  377. 

  378.         LIB_SYMBOL(client_name_size)

  379.         LIB_SYMBOL(get_client_name)

  380. 

  381.         LIB_SYMBOL(get_uuid_for_client_name)

  382.         LIB_SYMBOL(get_client_name_by_uuid)

  383. 

  384.         LIB_SYMBOL(activate)

  385.         LIB_SYMBOL(deactivate)

  386.         LIB_SYMBOL(is_realtime)

  387. 

  388.         LIB_SYMBOL(set_thread_init_callback)

  389.         LIB_SYMBOL(on_shutdown)

  390.         LIB_SYMBOL(on_info_shutdown)

  391.         LIB_SYMBOL(set_process_callback)

  392.         LIB_SYMBOL(set_freewheel_callback)

  393.         LIB_SYMBOL(set_buffer_size_callback)

  394.         LIB_SYMBOL(set_sample_rate_callback)

  395.         LIB_SYMBOL(set_client_registration_callback)

  396.         LIB_SYMBOL(set_port_registration_callback)

  397.         LIB_SYMBOL(set_port_rename_callback)

  398.         LIB_SYMBOL(set_port_connect_callback)

  399.         LIB_SYMBOL(set_graph_order_callback)

  400.         LIB_SYMBOL(set_xrun_callback)

  401.         LIB_SYMBOL(set_latency_callback)

  402. 

  403.         LIB_SYMBOL(set_freewheel)

  404.         LIB_SYMBOL(set_buffer_size)

  405. 

  406.         LIB_SYMBOL(get_sample_rate)

  407.         LIB_SYMBOL(get_buffer_size)

  408.         LIB_SYMBOL(cpu_load)

  409. 

  410.         LIB_SYMBOL(port_register)

  411.         LIB_SYMBOL(port_unregister)

  412.         LIB_SYMBOL(port_get_buffer)

  413. 

  414.         LIB_SYMBOL(port_name)

  415.         LIB_SYMBOL(port_uuid)

  416.         LIB_SYMBOL(port_short_name)

  417.         LIB_SYMBOL(port_flags)

  418.         LIB_SYMBOL(port_type)

  419.         LIB_SYMBOL(port_is_mine)

  420.         LIB_SYMBOL(port_connected)

  421.         LIB_SYMBOL(port_connected_to)

  422.         LIB_SYMBOL(port_get_connections)

  423.         LIB_SYMBOL(port_get_all_connections)

  424. 

  425.         LIB_SYMBOL(port_set_name)

  426.         LIB_SYMBOL(port_set_alias)

  427.         LIB_SYMBOL(port_unset_alias)

  428.         LIB_SYMBOL(port_get_aliases)

  429. 

  430.         LIB_SYMBOL(port_request_monitor)

  431.         LIB_SYMBOL(port_request_monitor_by_name)

  432.         LIB_SYMBOL(port_ensure_monitor)

  433.         LIB_SYMBOL(port_monitoring_input)

  434. 

  435.         LIB_SYMBOL(connect)

  436.         LIB_SYMBOL(disconnect)

  437.         LIB_SYMBOL(port_disconnect)

  438. 

  439.         LIB_SYMBOL(port_name_size)

  440.         LIB_SYMBOL(port_type_size)

  441.         LIB_SYMBOL(port_type_get_buffer_size)

  442. 

  443.         LIB_SYMBOL(port_get_latency_range)

  444.         LIB_SYMBOL(port_set_latency_range)

  445.         LIB_SYMBOL(recompute_total_latencies)

  446. 

  447.         LIB_SYMBOL(get_ports)

  448.         LIB_SYMBOL(port_by_name)

  449.         LIB_SYMBOL(port_by_id)

  450. 

  451.         LIB_SYMBOL(free)

  452. 

  453.         LIB_SYMBOL(midi_get_event_count)

  454.         LIB_SYMBOL(midi_event_get)

  455.         LIB_SYMBOL(midi_clear_buffer)

  456.         LIB_SYMBOL(midi_event_write)

  457.         LIB_SYMBOL(midi_event_reserve)

  458. 

  459.         LIB_SYMBOL(release_timebase)

  460.         LIB_SYMBOL(set_sync_callback)

  461.         LIB_SYMBOL(set_sync_timeout)

  462.         LIB_SYMBOL(set_timebase_callback)

  463.         LIB_SYMBOL(transport_locate)

  464.         LIB_SYMBOL(transport_query)

  465.         LIB_SYMBOL(get_current_transport_frame)

  466.         LIB_SYMBOL(transport_reposition)

  467.         LIB_SYMBOL(transport_start)

  468.         LIB_SYMBOL(transport_stop)

  469. 

  470.         LIB_SYMBOL(set_property)

  471.         LIB_SYMBOL(get_property)

  472.         LIB_SYMBOL(free_description)

  473.         LIB_SYMBOL(get_properties)

  474.         LIB_SYMBOL(get_all_properties)

  475.         LIB_SYMBOL(remove_property)

  476.         LIB_SYMBOL(remove_properties)

  477.         LIB_SYMBOL(remove_all_properties)

  478.         LIB_SYMBOL(set_property_change_callback)

  479. 

  480.         #undef JOIN

  481.         #undef LIB_SYMBOL

  482.     }

  483. 

  484.     ~JackBridge()

  485.     {

  486.         if (lib != nullptr)

  487.         {

  488.             lib_close(lib);

  489.             lib = nullptr;

  490.         }

  491.     }

  492. 

  493.     CARLA_DECLARE_NON_COPY_STRUCT(JackBridge);

  494. };

  495. 

  496. // -----------------------------------------------------------------------------

  497. 

  498. static const JackBridge& getBridgeInstance() noexcept

  499. {

  500.     static const JackBridge bridge;

  501.     return bridge;

  502. }

  503. 

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

  505. 

  506. // -----------------------------------------------------------------------------

  507. 

  508. bool jackbridge_is_ok(void) noexcept

  509. {

  510. #if defined(JACKBRIDGE_DUMMY)

  511.     return false;

  512. #elif defined(JACKBRIDGE_DIRECT)

  513.     return true;

  514. #else

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

  516. #endif

  517. }

  518. 

  519. // -----------------------------------------------------------------------------

  520. 

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

  522. {

  523. #if defined(JACKBRIDGE_DUMMY)

  524. #elif defined(JACKBRIDGE_DIRECT)

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

  526. #else

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

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

  529. #endif

  530.     if (major_ptr != nullptr)

  531.         *major_ptr = 0;

  532.     if (minor_ptr != nullptr)

  533.         *minor_ptr = 0;

  534.     if (micro_ptr != nullptr)

  535.         *micro_ptr = 0;

  536.     if (proto_ptr != nullptr)

  537.         *proto_ptr = 0;

  538. }

  539. 

  540. const char* jackbridge_get_version_string(void)

  541. {

  542. #if defined(JACKBRIDGE_DUMMY)

  543. #elif defined(JACKBRIDGE_DIRECT)

  544.     return jack_get_version_string();

  545. #else

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

  547.         return getBridgeInstance().get_version_string_ptr();

  548. #endif

  549.     return nullptr;

  550. }

  551. 

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

  553. 

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

  555. {

  556. #if defined(JACKBRIDGE_DUMMY)

  557. #elif defined(JACKBRIDGE_DIRECT)

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

  559. #else

  560.     carla_stdout("client_open AFTER %p 0x%x %p", client_name, options, status);

  561. 

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

  563.         return getBridgeInstance().client_open_ptr(client_name, options, status);

  564. #endif

  565.     if (status != nullptr)

  566.         *status = JackServerError;

  567.     return nullptr;

  568. }

  569. 

  570. bool jackbridge_client_close(jack_client_t* client)

  571. {

  572. #if defined(JACKBRIDGE_DUMMY)

  573. #elif defined(JACKBRIDGE_DIRECT)

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

  575. #else

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

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

  578. #endif

  579.     return false;

  580. }

  581. 

  582. // -----------------------------------------------------------------------------

  583. 

  584. int jackbridge_client_name_size(void)

  585. {

  586. #if defined(JACKBRIDGE_DUMMY)

  587. #elif defined(JACKBRIDGE_DIRECT)

  588.     return jack_client_name_size();

  589. #else

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

  591.         return getBridgeInstance().client_name_size_ptr();

  592. #endif

  593.     return 0;

  594. }

  595. 

  596. char* jackbridge_get_client_name(jack_client_t* client)

  597. {

  598. #if defined(JACKBRIDGE_DUMMY)

  599. #elif defined(JACKBRIDGE_DIRECT)

  600.     return jack_get_client_name(client);

  601. #else

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

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

  604. #endif

  605.     return nullptr;

  606. }

  607. 

  608. // -----------------------------------------------------------------------------

  609. 

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

  611. {

  612. #if defined(JACKBRIDGE_DUMMY)

  613. #elif defined(JACKBRIDGE_DIRECT)

  614.     return jack_get_uuid_for_client_name(client, name);

  615. #else

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

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

  618. #endif

  619.     return nullptr;

  620. }

  621. 

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

  623. {

  624. #if defined(JACKBRIDGE_DUMMY)

  625. #elif defined(JACKBRIDGE_DIRECT)

  626.     return jack_get_client_name_by_uuid(client, uuid);

  627. #else

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

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

  630. #endif

  631.     return nullptr;

  632. }

  633. 

  634. // -----------------------------------------------------------------------------

  635. 

  636. bool jackbridge_activate(jack_client_t* client)

  637. {

  638. #if defined(JACKBRIDGE_DUMMY)

  639. #elif defined(JACKBRIDGE_DIRECT)

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

  641. #else

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

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

  644. #endif

  645.     return false;

  646. }

  647. 

  648. bool jackbridge_deactivate(jack_client_t* client)

  649. {

  650. #if defined(JACKBRIDGE_DUMMY)

  651. #elif defined(JACKBRIDGE_DIRECT)

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

  653. #else

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

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

  656. #endif

  657.     return false;

  658. }

  659. 

  660. bool jackbridge_is_realtime(jack_client_t* client)

  661. {

  662. #if defined(JACKBRIDGE_DUMMY)

  663. #elif defined(JACKBRIDGE_DIRECT)

  664.     return jack_is_realtime(client);

  665. #else

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

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

  668. #endif

  669.     return false;

  670. }

  671. 

  672. // -----------------------------------------------------------------------------

  673. 

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

  675. {

  676. #if defined(JACKBRIDGE_DUMMY)

  677. #elif defined(JACKBRIDGE_DIRECT)

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

  679. #else

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

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

  682. #endif

  683.     return false;

  684. }

  685. 

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

  687. {

  688. #if defined(JACKBRIDGE_DUMMY)

  689. #elif defined(JACKBRIDGE_DIRECT)

  690.     jack_on_shutdown(client, shutdown_callback, arg);

  691. #else

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

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

  694. #endif

  695. }

  696. 

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

  698. {

  699. #if defined(JACKBRIDGE_DUMMY)

  700. #elif defined(JACKBRIDGE_DIRECT)

  701.     jack_on_info_shutdown(client, shutdown_callback, arg);

  702. #else

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

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

  705. #endif

  706. }

  707. 

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

  709. {

  710. #if defined(JACKBRIDGE_DUMMY)

  711. #elif defined(JACKBRIDGE_DIRECT)

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

  713. #else

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

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

  716. #endif

  717.     return false;

  718. }

  719. 

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

  721. {

  722. #if defined(JACKBRIDGE_DUMMY)

  723. #elif defined(JACKBRIDGE_DIRECT)

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

  725. #else

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

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

  728. #endif

  729.     return false;

  730. }

  731. 

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

  733. {

  734. #if defined(JACKBRIDGE_DUMMY)

  735. #elif defined(JACKBRIDGE_DIRECT)

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

  737. #else

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

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

  740. #endif

  741.     return false;

  742. }

  743. 

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

  745. {

  746. #if defined(JACKBRIDGE_DUMMY)

  747. #elif defined(JACKBRIDGE_DIRECT)

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

  749. #else

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

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

  752. #endif

  753.     return false;

  754. }

  755. 

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

  757. {

  758. #if defined(JACKBRIDGE_DUMMY)

  759. #elif defined(JACKBRIDGE_DIRECT)

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

  761. #else

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

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

  764. #endif

  765.     return false;

  766. }

  767. 

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

  769. {

  770. #if defined(JACKBRIDGE_DUMMY)

  771. #elif defined(JACKBRIDGE_DIRECT)

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

  773. #else

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

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

  776. #endif

  777.     return false;

  778. }

  779. 

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

  781. {

  782. #if defined(JACKBRIDGE_DUMMY)

  783. #elif defined(JACKBRIDGE_DIRECT)

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

  785. #else

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

  787.         return false;

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

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

  790. #endif

  791.     return false;

  792. }

  793. 

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

  795. {

  796. #if defined(JACKBRIDGE_DUMMY)

  797. #elif defined(JACKBRIDGE_DIRECT)

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

  799. #else

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

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

  802. #endif

  803.     return false;

  804. }

  805. 

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

  807. {

  808. #if defined(JACKBRIDGE_DUMMY)

  809. #elif defined(JACKBRIDGE_DIRECT)

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

  811. #else

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

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

  814. #endif

  815.     return false;

  816. }

  817. 

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

  819. {

  820. #if defined(JACKBRIDGE_DUMMY)

  821. #elif defined(JACKBRIDGE_DIRECT)

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

  823. #else

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

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

  826. #endif

  827.     return false;

  828. }

  829. 

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

  831. {

  832. #if defined(JACKBRIDGE_DUMMY)

  833. #elif defined(JACKBRIDGE_DIRECT)

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

  835. #else

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

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

  838. #endif

  839.     return false;

  840. }

  841. 

  842. // -----------------------------------------------------------------------------

  843. 

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

  845. {

  846. #if defined(JACKBRIDGE_DUMMY)

  847. #elif defined(JACKBRIDGE_DIRECT)

  848.     return jack_set_freewheel(client, onoff);

  849. #else

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

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

  852. #endif

  853.     return false;

  854. }

  855. 

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

  857. {

  858. #if defined(JACKBRIDGE_DUMMY)

  859. #elif defined(JACKBRIDGE_DIRECT)

  860.     return jack_set_buffer_size(client, nframes);

  861. #else

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

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

  864. #endif

  865.     return false;

  866. }

  867. 

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

  869. 

  870. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  871. {

  872. #if defined(JACKBRIDGE_DUMMY)

  873. #elif defined(JACKBRIDGE_DIRECT)

  874.     return jack_get_sample_rate(client);

  875. #else

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

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

  878. #endif

  879.     return 0;

  880. }

  881. 

  882. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  883. {

  884. #if defined(JACKBRIDGE_DUMMY)

  885. #elif defined(JACKBRIDGE_DIRECT)

  886.     return jack_get_buffer_size(client);

  887. #else

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

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

  890. #endif

  891.     return 0;

  892. }

  893. 

  894. float jackbridge_cpu_load(jack_client_t* client)

  895. {

  896. #if defined(JACKBRIDGE_DUMMY)

  897. #elif defined(JACKBRIDGE_DIRECT)

  898.     return jack_cpu_load(client);

  899. #else

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

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

  902. #endif

  903.     return 0.0f;

  904. }

  905. 

  906. // -----------------------------------------------------------------------------

  907. 

  908. jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, ulong flags, ulong buffer_size)

  909. {

  910. #if defined(JACKBRIDGE_DUMMY)

  911. #elif defined(JACKBRIDGE_DIRECT)

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

  913. #else

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

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

  916. #endif

  917.     return nullptr;

  918. }

  919. 

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

  921. {

  922. #if defined(JACKBRIDGE_DUMMY)

  923. #elif defined(JACKBRIDGE_DIRECT)

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

  925. #else

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

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

  928. #endif

  929.     return false;

  930. }

  931. 

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

  933. {

  934. #if defined(JACKBRIDGE_DUMMY)

  935. #elif defined(JACKBRIDGE_DIRECT)

  936.     return jack_port_get_buffer(port, nframes);

  937. #else

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

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

  940. #endif

  941.     return nullptr;

  942. }

  943. 

  944. // -----------------------------------------------------------------------------

  945. 

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

  947. {

  948. #if defined(JACKBRIDGE_DUMMY)

  949. #elif defined(JACKBRIDGE_DIRECT)

  950.     return jack_port_name(port);

  951. #else

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

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

  954. #endif

  955.     return nullptr;

  956. }

  957. 

  958. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  959. {

  960. #if defined(JACKBRIDGE_DUMMY)

  961. #elif defined(JACKBRIDGE_DIRECT)

  962.     return jack_port_uuid(port);

  963. #else

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

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

  966. #endif

  967.     return 0;

  968. }

  969. 

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

  971. {

  972. #if defined(JACKBRIDGE_DUMMY)

  973. #elif defined(JACKBRIDGE_DIRECT)

  974.     return jack_port_short_name(port);

  975. #else

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

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

  978. #endif

  979.     return nullptr;

  980. }

  981. 

  982. int jackbridge_port_flags(const jack_port_t* port)

  983. {

  984. #if defined(JACKBRIDGE_DUMMY)

  985. #elif defined(JACKBRIDGE_DIRECT)

  986.     return jack_port_flags(port);

  987. #else

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

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

  990. #endif

  991.     return 0x0;

  992. }

  993. 

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

  995. {

  996. #if defined(JACKBRIDGE_DUMMY)

  997. #elif defined(JACKBRIDGE_DIRECT)

  998.     return jack_port_type(port);

  999. #else

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

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

  1002. #endif

  1003.     return nullptr;

  1004. }

  1005. 

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

  1007. {

  1008. #if defined(JACKBRIDGE_DUMMY)

  1009. #elif defined(JACKBRIDGE_DIRECT)

  1010.     return jack_port_is_mine(client, port);

  1011. #else

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

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

  1014. #endif

  1015.     return false;

  1016. }

  1017. 

  1018. int jackbridge_port_connected(const jack_port_t* port)

  1019. {

  1020. #if defined(JACKBRIDGE_DUMMY)

  1021. #elif defined(JACKBRIDGE_DIRECT)

  1022.     return jack_port_connected(port);

  1023. #else

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

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

  1026. #endif

  1027.     return 0;

  1028. }

  1029. 

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

  1031. {

  1032. #if defined(JACKBRIDGE_DUMMY)

  1033. #elif defined(JACKBRIDGE_DIRECT)

  1034.     return jack_port_connected_to(port, port_name);

  1035. #else

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

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

  1038. #endif

  1039.     return false;

  1040. }

  1041. 

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

  1043. {

  1044. #if defined(JACKBRIDGE_DUMMY)

  1045. #elif defined(JACKBRIDGE_DIRECT)

  1046.     return jack_port_get_connections(port);

  1047. #else

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

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

  1050. #endif

  1051.     return nullptr;

  1052. }

  1053. 

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

  1055. {

  1056. #if defined(JACKBRIDGE_DUMMY)

  1057. #elif defined(JACKBRIDGE_DIRECT)

  1058.     return jack_port_get_all_connections(client, port);

  1059. #else

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

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

  1062. #endif

  1063.     return nullptr;

  1064. }

  1065. 

  1066. // -----------------------------------------------------------------------------

  1067. 

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

  1069. {

  1070. #if defined(JACKBRIDGE_DUMMY)

  1071. #elif defined(JACKBRIDGE_DIRECT)

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

  1073. #else

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

  1075.         return false;

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

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

  1078. #endif

  1079.     return false;

  1080. }

  1081. 

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

  1083. {

  1084. #if defined(JACKBRIDGE_DUMMY)

  1085. #elif defined(JACKBRIDGE_DIRECT)

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

  1087. #else

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

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

  1090. #endif

  1091.     return false;

  1092. }

  1093. 

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

  1095. {

  1096. #if defined(JACKBRIDGE_DUMMY)

  1097. #elif defined(JACKBRIDGE_DIRECT)

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

  1099. #else

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

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

  1102. #endif

  1103.     return false;

  1104. }

  1105. 

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

  1107. {

  1108. #if defined(JACKBRIDGE_DUMMY)

  1109. #elif defined(JACKBRIDGE_DIRECT)

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

  1111. #else

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

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

  1114. #endif

  1115.     return 0;

  1116. }

  1117. 

  1118. // -----------------------------------------------------------------------------

  1119. 

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

  1121. {

  1122. #if defined(JACKBRIDGE_DUMMY)

  1123. #elif defined(JACKBRIDGE_DIRECT)

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

  1125. #else

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

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

  1128. #endif

  1129.     return false;

  1130. }

  1131. 

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

  1133. {

  1134. #if defined(JACKBRIDGE_DUMMY)

  1135. #elif defined(JACKBRIDGE_DIRECT)

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

  1137. #else

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

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

  1140. #endif

  1141.     return false;

  1142. }

  1143. 

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

  1145. {

  1146. #if defined(JACKBRIDGE_DUMMY)

  1147. #elif defined(JACKBRIDGE_DIRECT)

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

  1149. #else

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

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

  1152. #endif

  1153.     return false;

  1154. }

  1155. 

  1156. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1157. {

  1158. #if defined(JACKBRIDGE_DUMMY)

  1159. #elif defined(JACKBRIDGE_DIRECT)

  1160.     return jack_port_monitoring_input(port);

  1161. #else

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

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

  1164. #endif

  1165.     return false;

  1166. }

  1167. 

  1168. // -----------------------------------------------------------------------------

  1169. 

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

  1171. {

  1172. #if defined(JACKBRIDGE_DUMMY)

  1173. #elif defined(JACKBRIDGE_DIRECT)

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

  1175. #else

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

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

  1178. #endif

  1179.     return false;

  1180. }

  1181. 

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

  1183. {

  1184. #if defined(JACKBRIDGE_DUMMY)

  1185. #elif defined(JACKBRIDGE_DIRECT)

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

  1187. #else

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

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

  1190. #endif

  1191.     return false;

  1192. }

  1193. 

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

  1195. {

  1196. #if defined(JACKBRIDGE_DUMMY)

  1197. #elif defined(JACKBRIDGE_DIRECT)

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

  1199. #else

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

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

  1202. #endif

  1203.     return false;

  1204. }

  1205. 

  1206. // -----------------------------------------------------------------------------

  1207. 

  1208. int jackbridge_port_name_size(void)

  1209. {

  1210. #if defined(JACKBRIDGE_DUMMY)

  1211. #elif defined(JACKBRIDGE_DIRECT)

  1212.     return jack_port_name_size();

  1213. #else

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

  1215.         return getBridgeInstance().port_name_size_ptr();

  1216. #endif

  1217.     return 0;

  1218. }

  1219. 

  1220. int jackbridge_port_type_size(void)

  1221. {

  1222. #if defined(JACKBRIDGE_DUMMY)

  1223. #elif defined(JACKBRIDGE_DIRECT)

  1224.     return jack_port_type_size();

  1225. #else

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

  1227.         return getBridgeInstance().port_type_size_ptr();

  1228. #endif

  1229.     return 0;

  1230. }

  1231. 

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

  1233. {

  1234. #if defined(JACKBRIDGE_DUMMY)

  1235. #elif defined(JACKBRIDGE_DIRECT)

  1236.     return jack_port_type_get_buffer_size(client, port_type);

  1237. #else

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

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

  1240. #endif

  1241.     return 0;

  1242. }

  1243. 

  1244. // -----------------------------------------------------------------------------

  1245. 

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

  1247. {

  1248. #if defined(JACKBRIDGE_DUMMY)

  1249. #elif defined(JACKBRIDGE_DIRECT)

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

  1251. #else

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

  1253.         return getBridgeInstance().port_get_latency_range_ptr(port, mode, range);

  1254. #endif

  1255.     range->min = 0;

  1256.     range->max = 0;

  1257. }

  1258. 

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

  1260. {

  1261. #if defined(JACKBRIDGE_DUMMY)

  1262. #elif defined(JACKBRIDGE_DIRECT)

  1263.     jack_port_set_latency_range(port, mode, range);

  1264. #else

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

  1266.         getBridgeInstance().port_set_latency_range_ptr(port, mode, range);

  1267. #endif

  1268. }

  1269. 

  1270. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1271. {

  1272. #if defined(JACKBRIDGE_DUMMY)

  1273. #elif defined(JACKBRIDGE_DIRECT)

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

  1275. #else

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

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

  1278. #endif

  1279.     return false;

  1280. }

  1281. 

  1282. // -----------------------------------------------------------------------------

  1283. 

  1284. const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, ulong flags)

  1285. {

  1286. #if defined(JACKBRIDGE_DUMMY)

  1287. #elif defined(JACKBRIDGE_DIRECT)

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

  1289. #else

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

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

  1292. #endif

  1293.     return nullptr;

  1294. }

  1295. 

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

  1297. {

  1298. #if defined(JACKBRIDGE_DUMMY)

  1299. #elif defined(JACKBRIDGE_DIRECT)

  1300.     return jack_port_by_name(client, port_name);

  1301. #else

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

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

  1304. #endif

  1305.     return nullptr;

  1306. }

  1307. 

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

  1309. {

  1310. #if defined(JACKBRIDGE_DUMMY)

  1311. #elif defined(JACKBRIDGE_DIRECT)

  1312.     return jack_port_by_id(client, port_id);

  1313. #else

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

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

  1316. #endif

  1317.     return nullptr;

  1318. }

  1319. 

  1320. // -----------------------------------------------------------------------------

  1321. 

  1322. void jackbridge_free(void* ptr)

  1323. {

  1324. #if defined(JACKBRIDGE_DUMMY)

  1325. #elif defined(JACKBRIDGE_DIRECT)

  1326.     return jack_free(ptr);

  1327. #else

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

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

  1330. 

  1331.     // just in case

  1332.     std::free(ptr);

  1333. #endif

  1334. }

  1335. 

  1336. // -----------------------------------------------------------------------------

  1337. 

  1338. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1339. {

  1340. #if defined(JACKBRIDGE_DUMMY)

  1341. #elif defined(JACKBRIDGE_DIRECT)

  1342.     return jack_midi_get_event_count(port_buffer);

  1343. #else

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

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

  1346. #endif

  1347.     return 0;

  1348. }

  1349. 

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

  1351. {

  1352. #if defined(JACKBRIDGE_DUMMY)

  1353. #elif defined(JACKBRIDGE_DIRECT)

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

  1355. #else

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

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

  1358. #endif

  1359.     return false;

  1360. }

  1361. 

  1362. void jackbridge_midi_clear_buffer(void* port_buffer)

  1363. {

  1364. #if defined(JACKBRIDGE_DUMMY)

  1365. #elif defined(JACKBRIDGE_DIRECT)

  1366.     jack_midi_clear_buffer(port_buffer);

  1367. #else

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

  1369.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1370. #endif

  1371. }

  1372. 

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

  1374. {

  1375. #if defined(JACKBRIDGE_DUMMY)

  1376. #elif defined(JACKBRIDGE_DIRECT)

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

  1378. #else

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

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

  1381. #endif

  1382.     return false;

  1383. }

  1384. 

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

  1386. {

  1387. #if defined(JACKBRIDGE_DUMMY)

  1388. #elif defined(JACKBRIDGE_DIRECT)

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

  1390. #else

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

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

  1393. #endif

  1394.     return nullptr;

  1395. }

  1396. 

  1397. // -----------------------------------------------------------------------------

  1398. 

  1399. bool jackbridge_release_timebase(jack_client_t* client)

  1400. {

  1401. #if defined(JACKBRIDGE_DUMMY)

  1402. #elif defined(JACKBRIDGE_DIRECT)

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

  1404. #else

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

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

  1407. #endif

  1408.     return false;

  1409. }

  1410. 

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

  1412. {

  1413. #if defined(JACKBRIDGE_DUMMY)

  1414. #elif defined(JACKBRIDGE_DIRECT)

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

  1416. #else

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

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

  1419. #endif

  1420.     return false;

  1421. }

  1422. 

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

  1424. {

  1425. #if defined(JACKBRIDGE_DUMMY)

  1426. #elif defined(JACKBRIDGE_DIRECT)

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

  1428. #else

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

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

  1431. #endif

  1432.     return false;

  1433. }

  1434. 

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

  1436. {

  1437. #if defined(JACKBRIDGE_DUMMY)

  1438. #elif defined(JACKBRIDGE_DIRECT)

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

  1440. #else

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

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

  1443. #endif

  1444.     return false;

  1445. }

  1446. 

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

  1448. {

  1449. #if defined(JACKBRIDGE_DUMMY)

  1450. #elif defined(JACKBRIDGE_DIRECT)

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

  1452. #else

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

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

  1455. #endif

  1456.     return false;

  1457. }

  1458. 

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

  1460. {

  1461. #if defined(JACKBRIDGE_DUMMY)

  1462. #elif defined(JACKBRIDGE_DIRECT)

  1463.     return jack_transport_query(client, pos);

  1464. #else

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

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

  1467. #endif

  1468.     if (pos != nullptr)

  1469.     {

  1470.         // invalidate

  1471.         pos->unique_1 = 0;

  1472.         pos->unique_2 = 1;

  1473.     }

  1474.     return JackTransportStopped;

  1475. }

  1476. 

  1477. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1478. {

  1479. #if defined(JACKBRIDGE_DUMMY)

  1480. #elif defined(JACKBRIDGE_DIRECT)

  1481.     return jack_get_current_transport_frame(client);

  1482. #else

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

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

  1485. #endif

  1486.     return 0;

  1487. }

  1488. 

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

  1490. {

  1491. #if defined(JACKBRIDGE_DUMMY)

  1492. #elif defined(JACKBRIDGE_DIRECT)

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

  1494. #else

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

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

  1497. #endif

  1498.     return false;

  1499. }

  1500. 

  1501. void jackbridge_transport_start(jack_client_t* client)

  1502. {

  1503. #if defined(JACKBRIDGE_DUMMY)

  1504. #elif defined(JACKBRIDGE_DIRECT)

  1505.     jack_transport_start(client);

  1506. #else

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

  1508.         getBridgeInstance().transport_start_ptr(client);

  1509. #endif

  1510. }

  1511. 

  1512. void jackbridge_transport_stop(jack_client_t* client)

  1513. {

  1514. #if defined(JACKBRIDGE_DUMMY)

  1515. #elif defined(JACKBRIDGE_DIRECT)

  1516.     jack_transport_stop(client);

  1517. #else

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

  1519.         getBridgeInstance().transport_stop_ptr(client);

  1520. #endif

  1521. }

  1522. 

  1523. // -----------------------------------------------------------------------------

  1524. 

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

  1526. {

  1527. #if defined(JACKBRIDGE_DUMMY)

  1528. #elif defined(JACKBRIDGE_DIRECT)

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

  1530. #else

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

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

  1533. #endif

  1534.     return false;

  1535. }

  1536. 

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

  1538. {

  1539. #if defined(JACKBRIDGE_DUMMY)

  1540. #elif defined(JACKBRIDGE_DIRECT)

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

  1542. #else

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

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

  1545. #endif

  1546.     return false;

  1547. }

  1548. 

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

  1550. {

  1551. #if defined(JACKBRIDGE_DUMMY)

  1552. #elif defined(JACKBRIDGE_DIRECT)

  1553.     jack_free_description(desc, free_description_itself);

  1554. #else

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

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

  1557. #endif

  1558. }

  1559. 

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

  1561. {

  1562. #if defined(JACKBRIDGE_DUMMY)

  1563. #elif defined(JACKBRIDGE_DIRECT)

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

  1565. #else

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

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

  1568. #endif

  1569.     return false;

  1570. }

  1571. 

  1572. bool jackbridge_get_all_properties(jack_description_t** descs)

  1573. {

  1574. #if defined(JACKBRIDGE_DUMMY)

  1575. #elif defined(JACKBRIDGE_DIRECT)

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

  1577. #else

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

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

  1580. #endif

  1581.     return false;

  1582. }

  1583. 

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

  1585. {

  1586. #if defined(JACKBRIDGE_DUMMY)

  1587. #elif defined(JACKBRIDGE_DIRECT)

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

  1589. #else

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

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

  1592. #endif

  1593.     return false;

  1594. }

  1595. 

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

  1597. {

  1598. #if defined(JACKBRIDGE_DUMMY)

  1599. #elif defined(JACKBRIDGE_DIRECT)

  1600.     return jack_remove_properties(client, subject);

  1601. #else

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

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

  1604. #endif

  1605.     return 0;

  1606. }

  1607. 

  1608. bool jackbridge_remove_all_properties(jack_client_t* client)

  1609. {

  1610. #if defined(JACKBRIDGE_DUMMY)

  1611. #elif defined(JACKBRIDGE_DIRECT)

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

  1613. #else

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

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

  1616. #endif

  1617.     return false;

  1618. }

  1619. 

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

  1621. {

  1622. #if defined(JACKBRIDGE_DUMMY)

  1623. #elif defined(JACKBRIDGE_DIRECT)

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

  1625. #else

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

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

  1628. #endif

  1629.     return false;

  1630. }

  1631. 

  1632. // -----------------------------------------------------------------------------