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

1631 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.     if (getBridgeInstance().client_open_ptr != nullptr)

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

  562. #endif

  563.     if (status != nullptr)

  564.         *status = JackServerError;

  565.     return nullptr;

  566. }

  567. 

  568. bool jackbridge_client_close(jack_client_t* client)

  569. {

  570. #if defined(JACKBRIDGE_DUMMY)

  571. #elif defined(JACKBRIDGE_DIRECT)

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

  573. #else

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

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

  576. #endif

  577.     return false;

  578. }

  579. 

  580. // -----------------------------------------------------------------------------

  581. 

  582. int jackbridge_client_name_size(void)

  583. {

  584. #if defined(JACKBRIDGE_DUMMY)

  585. #elif defined(JACKBRIDGE_DIRECT)

  586.     return jack_client_name_size();

  587. #else

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

  589.         return getBridgeInstance().client_name_size_ptr();

  590. #endif

  591.     return 0;

  592. }

  593. 

  594. char* jackbridge_get_client_name(jack_client_t* client)

  595. {

  596. #if defined(JACKBRIDGE_DUMMY)

  597. #elif defined(JACKBRIDGE_DIRECT)

  598.     return jack_get_client_name(client);

  599. #else

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

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

  602. #endif

  603.     return nullptr;

  604. }

  605. 

  606. // -----------------------------------------------------------------------------

  607. 

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

  609. {

  610. #if defined(JACKBRIDGE_DUMMY)

  611. #elif defined(JACKBRIDGE_DIRECT)

  612.     return jack_get_uuid_for_client_name(client, name);

  613. #else

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

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

  616. #endif

  617.     return nullptr;

  618. }

  619. 

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

  621. {

  622. #if defined(JACKBRIDGE_DUMMY)

  623. #elif defined(JACKBRIDGE_DIRECT)

  624.     return jack_get_client_name_by_uuid(client, uuid);

  625. #else

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

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

  628. #endif

  629.     return nullptr;

  630. }

  631. 

  632. // -----------------------------------------------------------------------------

  633. 

  634. bool jackbridge_activate(jack_client_t* client)

  635. {

  636. #if defined(JACKBRIDGE_DUMMY)

  637. #elif defined(JACKBRIDGE_DIRECT)

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

  639. #else

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

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

  642. #endif

  643.     return false;

  644. }

  645. 

  646. bool jackbridge_deactivate(jack_client_t* client)

  647. {

  648. #if defined(JACKBRIDGE_DUMMY)

  649. #elif defined(JACKBRIDGE_DIRECT)

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

  651. #else

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

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

  654. #endif

  655.     return false;

  656. }

  657. 

  658. bool jackbridge_is_realtime(jack_client_t* client)

  659. {

  660. #if defined(JACKBRIDGE_DUMMY)

  661. #elif defined(JACKBRIDGE_DIRECT)

  662.     return jack_is_realtime(client);

  663. #else

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

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

  666. #endif

  667.     return false;

  668. }

  669. 

  670. // -----------------------------------------------------------------------------

  671. 

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

  673. {

  674. #if defined(JACKBRIDGE_DUMMY)

  675. #elif defined(JACKBRIDGE_DIRECT)

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

  677. #else

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

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

  680. #endif

  681.     return false;

  682. }

  683. 

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

  685. {

  686. #if defined(JACKBRIDGE_DUMMY)

  687. #elif defined(JACKBRIDGE_DIRECT)

  688.     jack_on_shutdown(client, shutdown_callback, arg);

  689. #else

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

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

  692. #endif

  693. }

  694. 

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

  696. {

  697. #if defined(JACKBRIDGE_DUMMY)

  698. #elif defined(JACKBRIDGE_DIRECT)

  699.     jack_on_info_shutdown(client, shutdown_callback, arg);

  700. #else

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

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

  703. #endif

  704. }

  705. 

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

  707. {

  708. #if defined(JACKBRIDGE_DUMMY)

  709. #elif defined(JACKBRIDGE_DIRECT)

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

  711. #else

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

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

  714. #endif

  715.     return false;

  716. }

  717. 

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

  719. {

  720. #if defined(JACKBRIDGE_DUMMY)

  721. #elif defined(JACKBRIDGE_DIRECT)

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

  723. #else

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

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

  726. #endif

  727.     return false;

  728. }

  729. 

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

  731. {

  732. #if defined(JACKBRIDGE_DUMMY)

  733. #elif defined(JACKBRIDGE_DIRECT)

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

  735. #else

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

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

  738. #endif

  739.     return false;

  740. }

  741. 

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

  743. {

  744. #if defined(JACKBRIDGE_DUMMY)

  745. #elif defined(JACKBRIDGE_DIRECT)

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

  747. #else

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

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

  750. #endif

  751.     return false;

  752. }

  753. 

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

  755. {

  756. #if defined(JACKBRIDGE_DUMMY)

  757. #elif defined(JACKBRIDGE_DIRECT)

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

  759. #else

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

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

  762. #endif

  763.     return false;

  764. }

  765. 

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

  767. {

  768. #if defined(JACKBRIDGE_DUMMY)

  769. #elif defined(JACKBRIDGE_DIRECT)

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

  771. #else

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

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

  774. #endif

  775.     return false;

  776. }

  777. 

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

  779. {

  780. #if defined(JACKBRIDGE_DUMMY)

  781. #elif defined(JACKBRIDGE_DIRECT)

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

  783. #else

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

  785.         return false;

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

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

  788. #endif

  789.     return false;

  790. }

  791. 

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

  793. {

  794. #if defined(JACKBRIDGE_DUMMY)

  795. #elif defined(JACKBRIDGE_DIRECT)

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

  797. #else

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

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

  800. #endif

  801.     return false;

  802. }

  803. 

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

  805. {

  806. #if defined(JACKBRIDGE_DUMMY)

  807. #elif defined(JACKBRIDGE_DIRECT)

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

  809. #else

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

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

  812. #endif

  813.     return false;

  814. }

  815. 

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

  817. {

  818. #if defined(JACKBRIDGE_DUMMY)

  819. #elif defined(JACKBRIDGE_DIRECT)

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

  821. #else

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

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

  824. #endif

  825.     return false;

  826. }

  827. 

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

  829. {

  830. #if defined(JACKBRIDGE_DUMMY)

  831. #elif defined(JACKBRIDGE_DIRECT)

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

  833. #else

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

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

  836. #endif

  837.     return false;

  838. }

  839. 

  840. // -----------------------------------------------------------------------------

  841. 

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

  843. {

  844. #if defined(JACKBRIDGE_DUMMY)

  845. #elif defined(JACKBRIDGE_DIRECT)

  846.     return jack_set_freewheel(client, onoff);

  847. #else

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

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

  850. #endif

  851.     return false;

  852. }

  853. 

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

  855. {

  856. #if defined(JACKBRIDGE_DUMMY)

  857. #elif defined(JACKBRIDGE_DIRECT)

  858.     return jack_set_buffer_size(client, nframes);

  859. #else

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

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

  862. #endif

  863.     return false;

  864. }

  865. 

  866. // -----------------------------------------------------------------------------

  867. 

  868. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  869. {

  870. #if defined(JACKBRIDGE_DUMMY)

  871. #elif defined(JACKBRIDGE_DIRECT)

  872.     return jack_get_sample_rate(client);

  873. #else

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

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

  876. #endif

  877.     return 0;

  878. }

  879. 

  880. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  881. {

  882. #if defined(JACKBRIDGE_DUMMY)

  883. #elif defined(JACKBRIDGE_DIRECT)

  884.     return jack_get_buffer_size(client);

  885. #else

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

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

  888. #endif

  889.     return 0;

  890. }

  891. 

  892. float jackbridge_cpu_load(jack_client_t* client)

  893. {

  894. #if defined(JACKBRIDGE_DUMMY)

  895. #elif defined(JACKBRIDGE_DIRECT)

  896.     return jack_cpu_load(client);

  897. #else

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

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

  900. #endif

  901.     return 0.0f;

  902. }

  903. 

  904. // -----------------------------------------------------------------------------

  905. 

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

  907. {

  908. #if defined(JACKBRIDGE_DUMMY)

  909. #elif defined(JACKBRIDGE_DIRECT)

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

  911. #else

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

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

  914. #endif

  915.     return nullptr;

  916. }

  917. 

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

  919. {

  920. #if defined(JACKBRIDGE_DUMMY)

  921. #elif defined(JACKBRIDGE_DIRECT)

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

  923. #else

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

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

  926. #endif

  927.     return false;

  928. }

  929. 

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

  931. {

  932. #if defined(JACKBRIDGE_DUMMY)

  933. #elif defined(JACKBRIDGE_DIRECT)

  934.     return jack_port_get_buffer(port, nframes);

  935. #else

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

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

  938. #endif

  939.     return nullptr;

  940. }

  941. 

  942. // -----------------------------------------------------------------------------

  943. 

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

  945. {

  946. #if defined(JACKBRIDGE_DUMMY)

  947. #elif defined(JACKBRIDGE_DIRECT)

  948.     return jack_port_name(port);

  949. #else

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

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

  952. #endif

  953.     return nullptr;

  954. }

  955. 

  956. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  957. {

  958. #if defined(JACKBRIDGE_DUMMY)

  959. #elif defined(JACKBRIDGE_DIRECT)

  960.     return jack_port_uuid(port);

  961. #else

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

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

  964. #endif

  965.     return 0;

  966. }

  967. 

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

  969. {

  970. #if defined(JACKBRIDGE_DUMMY)

  971. #elif defined(JACKBRIDGE_DIRECT)

  972.     return jack_port_short_name(port);

  973. #else

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

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

  976. #endif

  977.     return nullptr;

  978. }

  979. 

  980. int jackbridge_port_flags(const jack_port_t* port)

  981. {

  982. #if defined(JACKBRIDGE_DUMMY)

  983. #elif defined(JACKBRIDGE_DIRECT)

  984.     return jack_port_flags(port);

  985. #else

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

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

  988. #endif

  989.     return 0x0;

  990. }

  991. 

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

  993. {

  994. #if defined(JACKBRIDGE_DUMMY)

  995. #elif defined(JACKBRIDGE_DIRECT)

  996.     return jack_port_type(port);

  997. #else

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

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

  1000. #endif

  1001.     return nullptr;

  1002. }

  1003. 

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

  1005. {

  1006. #if defined(JACKBRIDGE_DUMMY)

  1007. #elif defined(JACKBRIDGE_DIRECT)

  1008.     return jack_port_is_mine(client, port);

  1009. #else

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

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

  1012. #endif

  1013.     return false;

  1014. }

  1015. 

  1016. int jackbridge_port_connected(const jack_port_t* port)

  1017. {

  1018. #if defined(JACKBRIDGE_DUMMY)

  1019. #elif defined(JACKBRIDGE_DIRECT)

  1020.     return jack_port_connected(port);

  1021. #else

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

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

  1024. #endif

  1025.     return 0;

  1026. }

  1027. 

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

  1029. {

  1030. #if defined(JACKBRIDGE_DUMMY)

  1031. #elif defined(JACKBRIDGE_DIRECT)

  1032.     return jack_port_connected_to(port, port_name);

  1033. #else

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

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

  1036. #endif

  1037.     return false;

  1038. }

  1039. 

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

  1041. {

  1042. #if defined(JACKBRIDGE_DUMMY)

  1043. #elif defined(JACKBRIDGE_DIRECT)

  1044.     return jack_port_get_connections(port);

  1045. #else

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

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

  1048. #endif

  1049.     return nullptr;

  1050. }

  1051. 

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

  1053. {

  1054. #if defined(JACKBRIDGE_DUMMY)

  1055. #elif defined(JACKBRIDGE_DIRECT)

  1056.     return jack_port_get_all_connections(client, port);

  1057. #else

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

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

  1060. #endif

  1061.     return nullptr;

  1062. }

  1063. 

  1064. // -----------------------------------------------------------------------------

  1065. 

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

  1067. {

  1068. #if defined(JACKBRIDGE_DUMMY)

  1069. #elif defined(JACKBRIDGE_DIRECT)

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

  1071. #else

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

  1073.         return false;

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

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

  1076. #endif

  1077.     return false;

  1078. }

  1079. 

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

  1081. {

  1082. #if defined(JACKBRIDGE_DUMMY)

  1083. #elif defined(JACKBRIDGE_DIRECT)

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

  1085. #else

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

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

  1088. #endif

  1089.     return false;

  1090. }

  1091. 

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

  1093. {

  1094. #if defined(JACKBRIDGE_DUMMY)

  1095. #elif defined(JACKBRIDGE_DIRECT)

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

  1097. #else

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

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

  1100. #endif

  1101.     return false;

  1102. }

  1103. 

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

  1105. {

  1106. #if defined(JACKBRIDGE_DUMMY)

  1107. #elif defined(JACKBRIDGE_DIRECT)

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

  1109. #else

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

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

  1112. #endif

  1113.     return 0;

  1114. }

  1115. 

  1116. // -----------------------------------------------------------------------------

  1117. 

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

  1119. {

  1120. #if defined(JACKBRIDGE_DUMMY)

  1121. #elif defined(JACKBRIDGE_DIRECT)

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

  1123. #else

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

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

  1126. #endif

  1127.     return false;

  1128. }

  1129. 

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

  1131. {

  1132. #if defined(JACKBRIDGE_DUMMY)

  1133. #elif defined(JACKBRIDGE_DIRECT)

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

  1135. #else

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

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

  1138. #endif

  1139.     return false;

  1140. }

  1141. 

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

  1143. {

  1144. #if defined(JACKBRIDGE_DUMMY)

  1145. #elif defined(JACKBRIDGE_DIRECT)

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

  1147. #else

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

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

  1150. #endif

  1151.     return false;

  1152. }

  1153. 

  1154. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1155. {

  1156. #if defined(JACKBRIDGE_DUMMY)

  1157. #elif defined(JACKBRIDGE_DIRECT)

  1158.     return jack_port_monitoring_input(port);

  1159. #else

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

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

  1162. #endif

  1163.     return false;

  1164. }

  1165. 

  1166. // -----------------------------------------------------------------------------

  1167. 

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

  1169. {

  1170. #if defined(JACKBRIDGE_DUMMY)

  1171. #elif defined(JACKBRIDGE_DIRECT)

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

  1173. #else

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

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

  1176. #endif

  1177.     return false;

  1178. }

  1179. 

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

  1181. {

  1182. #if defined(JACKBRIDGE_DUMMY)

  1183. #elif defined(JACKBRIDGE_DIRECT)

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

  1185. #else

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

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

  1188. #endif

  1189.     return false;

  1190. }

  1191. 

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

  1193. {

  1194. #if defined(JACKBRIDGE_DUMMY)

  1195. #elif defined(JACKBRIDGE_DIRECT)

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

  1197. #else

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

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

  1200. #endif

  1201.     return false;

  1202. }

  1203. 

  1204. // -----------------------------------------------------------------------------

  1205. 

  1206. int jackbridge_port_name_size(void)

  1207. {

  1208. #if defined(JACKBRIDGE_DUMMY)

  1209. #elif defined(JACKBRIDGE_DIRECT)

  1210.     return jack_port_name_size();

  1211. #else

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

  1213.         return getBridgeInstance().port_name_size_ptr();

  1214. #endif

  1215.     return 0;

  1216. }

  1217. 

  1218. int jackbridge_port_type_size(void)

  1219. {

  1220. #if defined(JACKBRIDGE_DUMMY)

  1221. #elif defined(JACKBRIDGE_DIRECT)

  1222.     return jack_port_type_size();

  1223. #else

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

  1225.         return getBridgeInstance().port_type_size_ptr();

  1226. #endif

  1227.     return 0;

  1228. }

  1229. 

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

  1231. {

  1232. #if defined(JACKBRIDGE_DUMMY)

  1233. #elif defined(JACKBRIDGE_DIRECT)

  1234.     return jack_port_type_get_buffer_size(client, port_type);

  1235. #else

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

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

  1238. #endif

  1239.     return 0;

  1240. }

  1241. 

  1242. // -----------------------------------------------------------------------------

  1243. 

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

  1245. {

  1246. #if defined(JACKBRIDGE_DUMMY)

  1247. #elif defined(JACKBRIDGE_DIRECT)

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

  1249. #else

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

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

  1252. #endif

  1253.     range->min = 0;

  1254.     range->max = 0;

  1255. }

  1256. 

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

  1258. {

  1259. #if defined(JACKBRIDGE_DUMMY)

  1260. #elif defined(JACKBRIDGE_DIRECT)

  1261.     jack_port_set_latency_range(port, mode, range);

  1262. #else

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

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

  1265. #endif

  1266. }

  1267. 

  1268. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1269. {

  1270. #if defined(JACKBRIDGE_DUMMY)

  1271. #elif defined(JACKBRIDGE_DIRECT)

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

  1273. #else

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

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

  1276. #endif

  1277.     return false;

  1278. }

  1279. 

  1280. // -----------------------------------------------------------------------------

  1281. 

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

  1283. {

  1284. #if defined(JACKBRIDGE_DUMMY)

  1285. #elif defined(JACKBRIDGE_DIRECT)

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

  1287. #else

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

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

  1290. #endif

  1291.     return nullptr;

  1292. }

  1293. 

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

  1295. {

  1296. #if defined(JACKBRIDGE_DUMMY)

  1297. #elif defined(JACKBRIDGE_DIRECT)

  1298.     return jack_port_by_name(client, port_name);

  1299. #else

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

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

  1302. #endif

  1303.     return nullptr;

  1304. }

  1305. 

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

  1307. {

  1308. #if defined(JACKBRIDGE_DUMMY)

  1309. #elif defined(JACKBRIDGE_DIRECT)

  1310.     return jack_port_by_id(client, port_id);

  1311. #else

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

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

  1314. #endif

  1315.     return nullptr;

  1316. }

  1317. 

  1318. // -----------------------------------------------------------------------------

  1319. 

  1320. void jackbridge_free(void* ptr)

  1321. {

  1322. #if defined(JACKBRIDGE_DUMMY)

  1323. #elif defined(JACKBRIDGE_DIRECT)

  1324.     return jack_free(ptr);

  1325. #else

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

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

  1328. 

  1329.     // just in case

  1330.     std::free(ptr);

  1331. #endif

  1332. }

  1333. 

  1334. // -----------------------------------------------------------------------------

  1335. 

  1336. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1337. {

  1338. #if defined(JACKBRIDGE_DUMMY)

  1339. #elif defined(JACKBRIDGE_DIRECT)

  1340.     return jack_midi_get_event_count(port_buffer);

  1341. #else

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

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

  1344. #endif

  1345.     return 0;

  1346. }

  1347. 

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

  1349. {

  1350. #if defined(JACKBRIDGE_DUMMY)

  1351. #elif defined(JACKBRIDGE_DIRECT)

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

  1353. #else

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

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

  1356. #endif

  1357.     return false;

  1358. }

  1359. 

  1360. void jackbridge_midi_clear_buffer(void* port_buffer)

  1361. {

  1362. #if defined(JACKBRIDGE_DUMMY)

  1363. #elif defined(JACKBRIDGE_DIRECT)

  1364.     jack_midi_clear_buffer(port_buffer);

  1365. #else

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

  1367.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1368. #endif

  1369. }

  1370. 

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

  1372. {

  1373. #if defined(JACKBRIDGE_DUMMY)

  1374. #elif defined(JACKBRIDGE_DIRECT)

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

  1376. #else

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

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

  1379. #endif

  1380.     return false;

  1381. }

  1382. 

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

  1384. {

  1385. #if defined(JACKBRIDGE_DUMMY)

  1386. #elif defined(JACKBRIDGE_DIRECT)

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

  1388. #else

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

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

  1391. #endif

  1392.     return nullptr;

  1393. }

  1394. 

  1395. // -----------------------------------------------------------------------------

  1396. 

  1397. bool jackbridge_release_timebase(jack_client_t* client)

  1398. {

  1399. #if defined(JACKBRIDGE_DUMMY)

  1400. #elif defined(JACKBRIDGE_DIRECT)

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

  1402. #else

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

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

  1405. #endif

  1406.     return false;

  1407. }

  1408. 

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

  1410. {

  1411. #if defined(JACKBRIDGE_DUMMY)

  1412. #elif defined(JACKBRIDGE_DIRECT)

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

  1414. #else

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

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

  1417. #endif

  1418.     return false;

  1419. }

  1420. 

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

  1422. {

  1423. #if defined(JACKBRIDGE_DUMMY)

  1424. #elif defined(JACKBRIDGE_DIRECT)

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

  1426. #else

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

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

  1429. #endif

  1430.     return false;

  1431. }

  1432. 

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

  1434. {

  1435. #if defined(JACKBRIDGE_DUMMY)

  1436. #elif defined(JACKBRIDGE_DIRECT)

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

  1438. #else

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

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

  1441. #endif

  1442.     return false;

  1443. }

  1444. 

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

  1446. {

  1447. #if defined(JACKBRIDGE_DUMMY)

  1448. #elif defined(JACKBRIDGE_DIRECT)

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

  1450. #else

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

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

  1453. #endif

  1454.     return false;

  1455. }

  1456. 

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

  1458. {

  1459. #if defined(JACKBRIDGE_DUMMY)

  1460. #elif defined(JACKBRIDGE_DIRECT)

  1461.     return jack_transport_query(client, pos);

  1462. #else

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

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

  1465. #endif

  1466.     if (pos != nullptr)

  1467.     {

  1468.         // invalidate

  1469.         pos->unique_1 = 0;

  1470.         pos->unique_2 = 1;

  1471.     }

  1472.     return JackTransportStopped;

  1473. }

  1474. 

  1475. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1476. {

  1477. #if defined(JACKBRIDGE_DUMMY)

  1478. #elif defined(JACKBRIDGE_DIRECT)

  1479.     return jack_get_current_transport_frame(client);

  1480. #else

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

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

  1483. #endif

  1484.     return 0;

  1485. }

  1486. 

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

  1488. {

  1489. #if defined(JACKBRIDGE_DUMMY)

  1490. #elif defined(JACKBRIDGE_DIRECT)

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

  1492. #else

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

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

  1495. #endif

  1496.     return false;

  1497. }

  1498. 

  1499. void jackbridge_transport_start(jack_client_t* client)

  1500. {

  1501. #if defined(JACKBRIDGE_DUMMY)

  1502. #elif defined(JACKBRIDGE_DIRECT)

  1503.     jack_transport_start(client);

  1504. #else

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

  1506.         getBridgeInstance().transport_start_ptr(client);

  1507. #endif

  1508. }

  1509. 

  1510. void jackbridge_transport_stop(jack_client_t* client)

  1511. {

  1512. #if defined(JACKBRIDGE_DUMMY)

  1513. #elif defined(JACKBRIDGE_DIRECT)

  1514.     jack_transport_stop(client);

  1515. #else

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

  1517.         getBridgeInstance().transport_stop_ptr(client);

  1518. #endif

  1519. }

  1520. 

  1521. // -----------------------------------------------------------------------------

  1522. 

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

  1524. {

  1525. #if defined(JACKBRIDGE_DUMMY)

  1526. #elif defined(JACKBRIDGE_DIRECT)

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

  1528. #else

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

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

  1531. #endif

  1532.     return false;

  1533. }

  1534. 

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

  1536. {

  1537. #if defined(JACKBRIDGE_DUMMY)

  1538. #elif defined(JACKBRIDGE_DIRECT)

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

  1540. #else

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

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

  1543. #endif

  1544.     return false;

  1545. }

  1546. 

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

  1548. {

  1549. #if defined(JACKBRIDGE_DUMMY)

  1550. #elif defined(JACKBRIDGE_DIRECT)

  1551.     jack_free_description(desc, free_description_itself);

  1552. #else

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

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

  1555. #endif

  1556. }

  1557. 

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

  1559. {

  1560. #if defined(JACKBRIDGE_DUMMY)

  1561. #elif defined(JACKBRIDGE_DIRECT)

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

  1563. #else

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

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

  1566. #endif

  1567.     return false;

  1568. }

  1569. 

  1570. bool jackbridge_get_all_properties(jack_description_t** descs)

  1571. {

  1572. #if defined(JACKBRIDGE_DUMMY)

  1573. #elif defined(JACKBRIDGE_DIRECT)

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

  1575. #else

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

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

  1578. #endif

  1579.     return false;

  1580. }

  1581. 

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

  1583. {

  1584. #if defined(JACKBRIDGE_DUMMY)

  1585. #elif defined(JACKBRIDGE_DIRECT)

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

  1587. #else

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

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

  1590. #endif

  1591.     return false;

  1592. }

  1593. 

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

  1595. {

  1596. #if defined(JACKBRIDGE_DUMMY)

  1597. #elif defined(JACKBRIDGE_DIRECT)

  1598.     return jack_remove_properties(client, subject);

  1599. #else

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

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

  1602. #endif

  1603.     return 0;

  1604. }

  1605. 

  1606. bool jackbridge_remove_all_properties(jack_client_t* client)

  1607. {

  1608. #if defined(JACKBRIDGE_DUMMY)

  1609. #elif defined(JACKBRIDGE_DIRECT)

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

  1611. #else

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

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

  1614. #endif

  1615.     return false;

  1616. }

  1617. 

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

  1619. {

  1620. #if defined(JACKBRIDGE_DUMMY)

  1621. #elif defined(JACKBRIDGE_DIRECT)

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

  1623. #else

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

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

  1626. #endif

  1627.     return false;

  1628. }

  1629. 

  1630. // -----------------------------------------------------------------------------