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

1515 lines
48KB
Raw Blame History 

  1. /*

  2.  * JackBridge (Part 1, JACK functions)

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

  4.  *

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

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

  7.  * permission notice appear in all copies.

  8.  *

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

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

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

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

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

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

  15.  */

  16. 

  17. #include "JackBridge.hpp"

  18. 

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

  20. 

  21. #include "CarlaLibUtils.hpp"

  22. 

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

  24. 

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

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

  27. 

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

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

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

  31. 

  32. typedef int   (*jacksym_client_name_size)();

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

  34. 

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

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

  37. 

  38. typedef int (*jacksym_get_client_pid)(const char*);

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

  40. 

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

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

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

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

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

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

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

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

  49. typedef int  (*jacksym_set_client_rename_callback)(jack_client_t*, JackClientRenameCallback, void*);

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

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

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

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

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

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

  56. 

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

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

  59. 

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

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

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

  63. 

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

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

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

  67. 

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

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

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

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

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

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

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

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

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

  77. 

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

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

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

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

  82. 

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

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

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

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

  87. 

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

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

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

  91. 

  92. typedef int    (*jacksym_port_name_size)();

  93. typedef int    (*jacksym_port_type_size)();

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

  95. 

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

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

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

  99. 

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

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

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

  103. 

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

  105. 

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

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

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

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

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

  111. 

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

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

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

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

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

  117. 

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

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

  120. 

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

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

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

  124. 

  125. typedef int (*jacksym_custom_publish_data)(jack_client_t*, const char*, const void*, size_t);

  126. typedef int (*jacksym_custom_get_data)(jack_client_t*, const char*, const char*, void**, size_t*);

  127. typedef int (*jacksym_custom_unpublish_data)(jack_client_t*, const char*);

  128. typedef int (*jacksym_custom_set_data_appearance_callback)(jack_client_t*, JackCustomDataAppearanceCallback, void*);

  129. typedef const char** (*jacksym_custom_get_keys)(jack_client_t*, const char*);

  130. 

  131. // -----------------------------------------------------------------------------

  132. 

  133. struct JackBridge {

  134.     void* lib;

  135. 

  136.     jacksym_get_version get_version_ptr;

  137.     jacksym_get_version_string get_version_string_ptr;

  138. 

  139.     jacksym_client_open client_open_ptr;

  140.     jacksym_client_rename client_rename_ptr;

  141.     jacksym_client_close client_close_ptr;

  142. 

  143.     jacksym_client_name_size client_name_size_ptr;

  144.     jacksym_get_client_name get_client_name_ptr;

  145. 

  146.     jacksym_activate activate_ptr;

  147.     jacksym_deactivate deactivate_ptr;

  148. 

  149.     jacksym_get_client_pid get_client_pid_ptr;

  150.     jacksym_is_realtime is_realtime_ptr;

  151. 

  152.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  153.     jacksym_on_shutdown on_shutdown_ptr;

  154.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  155.     jacksym_set_process_callback set_process_callback_ptr;

  156.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  157.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  158.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  159.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  160.     jacksym_set_client_rename_callback set_client_rename_callback_ptr;

  161.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  162.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  163.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  164.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  165.     jacksym_set_latency_callback set_latency_callback_ptr;

  166. 

  167.     jacksym_set_freewheel set_freewheel_ptr;

  168.     jacksym_set_buffer_size set_buffer_size_ptr;

  169. 

  170.     jacksym_get_sample_rate get_sample_rate_ptr;

  171.     jacksym_get_buffer_size get_buffer_size_ptr;

  172.     jacksym_cpu_load cpu_load_ptr;

  173. 

  174.     jacksym_port_register port_register_ptr;

  175.     jacksym_port_unregister port_unregister_ptr;

  176.     jacksym_port_get_buffer port_get_buffer_ptr;

  177. 

  178.     jacksym_port_name port_name_ptr;

  179.     jacksym_port_short_name port_short_name_ptr;

  180.     jacksym_port_flags port_flags_ptr;

  181.     jacksym_port_type port_type_ptr;

  182.     jacksym_port_is_mine port_is_mine_ptr;

  183.     jacksym_port_connected port_connected_ptr;

  184.     jacksym_port_connected_to port_connected_to_ptr;

  185.     jacksym_port_get_connections port_get_connections_ptr;

  186.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  187. 

  188.     jacksym_port_set_name port_set_name_ptr;

  189.     jacksym_port_set_alias port_set_alias_ptr;

  190.     jacksym_port_unset_alias port_unset_alias_ptr;

  191.     jacksym_port_get_aliases port_get_aliases_ptr;

  192. 

  193.     jacksym_port_request_monitor port_request_monitor_ptr;

  194.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  195.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  196.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  197. 

  198.     jacksym_connect connect_ptr;

  199.     jacksym_disconnect disconnect_ptr;

  200.     jacksym_port_disconnect port_disconnect_ptr;

  201. 

  202.     jacksym_port_name_size port_name_size_ptr;

  203.     jacksym_port_type_size port_type_size_ptr;

  204.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  205. 

  206.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  207.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  208.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  209. 

  210.     jacksym_get_ports get_ports_ptr;

  211.     jacksym_port_by_name port_by_name_ptr;

  212.     jacksym_port_by_id port_by_id_ptr;

  213. 

  214.     jacksym_free free_ptr;

  215. 

  216.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  217.     jacksym_midi_event_get midi_event_get_ptr;

  218.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  219.     jacksym_midi_event_write midi_event_write_ptr;

  220.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  221. 

  222.     jacksym_release_timebase release_timebase_ptr;

  223.     jacksym_set_sync_callback set_sync_callback_ptr;

  224.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  225.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  226.     jacksym_transport_locate transport_locate_ptr;

  227. 

  228.     jacksym_transport_query transport_query_ptr;

  229.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  230. 

  231.     jacksym_transport_reposition transport_reposition_ptr;

  232.     jacksym_transport_start transport_start_ptr;

  233.     jacksym_transport_stop transport_stop_ptr;

  234. 

  235.     jacksym_custom_publish_data custom_publish_data_ptr;

  236.     jacksym_custom_get_data custom_get_data_ptr;

  237.     jacksym_custom_unpublish_data custom_unpublish_data_ptr;

  238.     jacksym_custom_set_data_appearance_callback custom_set_data_appearance_callback_ptr;

  239.     jacksym_custom_get_keys custom_get_keys_ptr;

  240. 

  241.     JackBridge()

  242.         : lib(nullptr),

  243.           get_version_ptr(nullptr),

  244.           get_version_string_ptr(nullptr),

  245.           client_open_ptr(nullptr),

  246.           client_rename_ptr(nullptr),

  247.           client_close_ptr(nullptr),

  248.           client_name_size_ptr(nullptr),

  249.           get_client_name_ptr(nullptr),

  250.           activate_ptr(nullptr),

  251.           deactivate_ptr(nullptr),

  252.           get_client_pid_ptr(nullptr),

  253.           is_realtime_ptr(nullptr),

  254.           set_thread_init_callback_ptr(nullptr),

  255.           on_shutdown_ptr(nullptr),

  256.           on_info_shutdown_ptr(nullptr),

  257.           set_process_callback_ptr(nullptr),

  258.           set_freewheel_callback_ptr(nullptr),

  259.           set_buffer_size_callback_ptr(nullptr),

  260.           set_sample_rate_callback_ptr(nullptr),

  261.           set_client_registration_callback_ptr(nullptr),

  262.           set_client_rename_callback_ptr(nullptr),

  263.           set_port_registration_callback_ptr(nullptr),

  264.           set_port_connect_callback_ptr(nullptr),

  265.           set_port_rename_callback_ptr(nullptr),

  266.           set_xrun_callback_ptr(nullptr),

  267.           set_latency_callback_ptr(nullptr),

  268.           set_freewheel_ptr(nullptr),

  269.           set_buffer_size_ptr(nullptr),

  270.           get_sample_rate_ptr(nullptr),

  271.           get_buffer_size_ptr(nullptr),

  272.           cpu_load_ptr(nullptr),

  273.           port_register_ptr(nullptr),

  274.           port_unregister_ptr(nullptr),

  275.           port_get_buffer_ptr(nullptr),

  276.           port_name_ptr(nullptr),

  277.           port_short_name_ptr(nullptr),

  278.           port_flags_ptr(nullptr),

  279.           port_type_ptr(nullptr),

  280.           port_is_mine_ptr(nullptr),

  281.           port_connected_ptr(nullptr),

  282.           port_connected_to_ptr(nullptr),

  283.           port_get_connections_ptr(nullptr),

  284.           port_get_all_connections_ptr(nullptr),

  285.           port_set_name_ptr(nullptr),

  286.           port_set_alias_ptr(nullptr),

  287.           port_unset_alias_ptr(nullptr),

  288.           port_get_aliases_ptr(nullptr),

  289.           port_request_monitor_ptr(nullptr),

  290.           port_request_monitor_by_name_ptr(nullptr),

  291.           port_ensure_monitor_ptr(nullptr),

  292.           port_monitoring_input_ptr(nullptr),

  293.           connect_ptr(nullptr),

  294.           disconnect_ptr(nullptr),

  295.           port_disconnect_ptr(nullptr),

  296.           port_name_size_ptr(nullptr),

  297.           port_type_size_ptr(nullptr),

  298.           port_type_get_buffer_size_ptr(nullptr),

  299.           port_get_latency_range_ptr(nullptr),

  300.           port_set_latency_range_ptr(nullptr),

  301.           recompute_total_latencies_ptr(nullptr),

  302.           get_ports_ptr(nullptr),

  303.           port_by_name_ptr(nullptr),

  304.           port_by_id_ptr(nullptr),

  305.           free_ptr(nullptr),

  306.           midi_get_event_count_ptr(nullptr),

  307.           midi_event_get_ptr(nullptr),

  308.           midi_clear_buffer_ptr(nullptr),

  309.           midi_event_write_ptr(nullptr),

  310.           midi_event_reserve_ptr(nullptr),

  311.           release_timebase_ptr(nullptr),

  312.           set_sync_callback_ptr(nullptr),

  313.           set_sync_timeout_ptr(nullptr),

  314.           set_timebase_callback_ptr(nullptr),

  315.           transport_locate_ptr(nullptr),

  316.           transport_query_ptr(nullptr),

  317.           get_current_transport_frame_ptr(nullptr),

  318.           transport_reposition_ptr(nullptr),

  319.           transport_start_ptr(nullptr),

  320.           transport_stop_ptr(nullptr),

  321.           custom_publish_data_ptr(nullptr),

  322.           custom_get_data_ptr(nullptr),

  323.           custom_unpublish_data_ptr(nullptr),

  324.           custom_set_data_appearance_callback_ptr(nullptr),

  325.           custom_get_keys_ptr(nullptr)

  326.     {

  327. # if defined(CARLA_OS_MAC)

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

  329. # elif defined(CARLA_OS_WIN)

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

  331. # else

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

  333. # endif

  334. 

  335.         lib = lib_open(filename);

  336. 

  337.         if (lib == nullptr)

  338.         {

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

  340.             return;

  341.         }

  342.         else

  343.         {

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

  345.         }

  346. 

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

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

  349. 

  350.         LIB_SYMBOL(get_version)

  351.         LIB_SYMBOL(get_version_string)

  352. 

  353.         LIB_SYMBOL(client_open)

  354.         LIB_SYMBOL(client_rename)

  355.         LIB_SYMBOL(client_close)

  356. 

  357.         LIB_SYMBOL(client_name_size)

  358.         LIB_SYMBOL(get_client_name)

  359. 

  360.         LIB_SYMBOL(activate)

  361.         LIB_SYMBOL(deactivate)

  362. 

  363.         LIB_SYMBOL(get_client_pid)

  364.         LIB_SYMBOL(is_realtime)

  365. 

  366.         LIB_SYMBOL(set_thread_init_callback)

  367.         LIB_SYMBOL(on_shutdown)

  368.         LIB_SYMBOL(on_info_shutdown)

  369.         LIB_SYMBOL(set_process_callback)

  370.         LIB_SYMBOL(set_freewheel_callback)

  371.         LIB_SYMBOL(set_buffer_size_callback)

  372.         LIB_SYMBOL(set_sample_rate_callback)

  373.         LIB_SYMBOL(set_client_registration_callback)

  374.         LIB_SYMBOL(set_client_rename_callback)

  375.         LIB_SYMBOL(set_port_registration_callback)

  376.         LIB_SYMBOL(set_port_connect_callback)

  377.         LIB_SYMBOL(set_port_rename_callback)

  378.         LIB_SYMBOL(set_xrun_callback)

  379.         LIB_SYMBOL(set_latency_callback)

  380. 

  381.         LIB_SYMBOL(set_freewheel)

  382.         LIB_SYMBOL(set_buffer_size)

  383. 

  384.         LIB_SYMBOL(get_sample_rate)

  385.         LIB_SYMBOL(get_buffer_size)

  386.         LIB_SYMBOL(cpu_load)

  387. 

  388.         LIB_SYMBOL(port_register)

  389.         LIB_SYMBOL(port_unregister)

  390.         LIB_SYMBOL(port_get_buffer)

  391. 

  392.         LIB_SYMBOL(port_name)

  393.         LIB_SYMBOL(port_short_name)

  394.         LIB_SYMBOL(port_flags)

  395.         LIB_SYMBOL(port_type)

  396.         LIB_SYMBOL(port_is_mine)

  397.         LIB_SYMBOL(port_connected)

  398.         LIB_SYMBOL(port_connected_to)

  399.         LIB_SYMBOL(port_get_connections)

  400.         LIB_SYMBOL(port_get_all_connections)

  401. 

  402.         LIB_SYMBOL(port_set_name)

  403.         LIB_SYMBOL(port_set_alias)

  404.         LIB_SYMBOL(port_unset_alias)

  405.         LIB_SYMBOL(port_get_aliases)

  406. 

  407.         LIB_SYMBOL(port_request_monitor)

  408.         LIB_SYMBOL(port_request_monitor_by_name)

  409.         LIB_SYMBOL(port_ensure_monitor)

  410.         LIB_SYMBOL(port_monitoring_input)

  411. 

  412.         LIB_SYMBOL(connect)

  413.         LIB_SYMBOL(disconnect)

  414.         LIB_SYMBOL(port_disconnect)

  415. 

  416.         LIB_SYMBOL(port_name_size)

  417.         LIB_SYMBOL(port_type_size)

  418.         LIB_SYMBOL(port_type_get_buffer_size)

  419. 

  420.         LIB_SYMBOL(port_get_latency_range)

  421.         LIB_SYMBOL(port_set_latency_range)

  422.         LIB_SYMBOL(recompute_total_latencies)

  423. 

  424.         LIB_SYMBOL(get_ports)

  425.         LIB_SYMBOL(port_by_name)

  426.         LIB_SYMBOL(port_by_id)

  427. 

  428.         LIB_SYMBOL(free)

  429. 

  430.         LIB_SYMBOL(midi_get_event_count)

  431.         LIB_SYMBOL(midi_event_get)

  432.         LIB_SYMBOL(midi_clear_buffer)

  433.         LIB_SYMBOL(midi_event_write)

  434.         LIB_SYMBOL(midi_event_reserve)

  435. 

  436.         LIB_SYMBOL(release_timebase)

  437.         LIB_SYMBOL(set_sync_callback)

  438.         LIB_SYMBOL(set_sync_timeout)

  439.         LIB_SYMBOL(set_timebase_callback)

  440.         LIB_SYMBOL(transport_locate)

  441.         LIB_SYMBOL(transport_query)

  442.         LIB_SYMBOL(get_current_transport_frame)

  443.         LIB_SYMBOL(transport_reposition)

  444.         LIB_SYMBOL(transport_start)

  445.         LIB_SYMBOL(transport_stop)

  446. 

  447.         LIB_SYMBOL(custom_publish_data)

  448.         LIB_SYMBOL(custom_get_data)

  449.         LIB_SYMBOL(custom_unpublish_data)

  450.         LIB_SYMBOL(custom_set_data_appearance_callback)

  451.         LIB_SYMBOL(custom_get_keys)

  452. 

  453.         #undef JOIN

  454.         #undef LIB_SYMBOL

  455.     }

  456. 

  457.     ~JackBridge()

  458.     {

  459.         if (lib != nullptr)

  460.             lib_close(lib);

  461.     }

  462. };

  463. 

  464. static JackBridge bridge;

  465. 

  466. #endif // ! JACKBRIDGE_DIRECT

  467. 

  468. // -----------------------------------------------------------------------------

  469. 

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

  471. {

  472. #if JACKBRIDGE_DUMMY

  473. #elif JACKBRIDGE_DIRECT

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

  475. #else

  476.     if (bridge.get_version_ptr != nullptr)

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

  478. #endif

  479.     if (major_ptr != nullptr)

  480.         *major_ptr = 0;

  481.     if (minor_ptr != nullptr)

  482.         *minor_ptr = 0;

  483.     if (micro_ptr != nullptr)

  484.         *micro_ptr = 0;

  485.     if (proto_ptr != nullptr)

  486.         *proto_ptr = 0;

  487. }

  488. 

  489. const char* jackbridge_get_version_string()

  490. {

  491. #if JACKBRIDGE_DUMMY

  492. #elif JACKBRIDGE_DIRECT

  493.     return jack_get_version_string();

  494. #else

  495.     if (bridge.get_version_string_ptr != nullptr)

  496.         return bridge.get_version_string_ptr();

  497. #endif

  498.     return nullptr;

  499. }

  500. 

  501. // -----------------------------------------------------------------------------

  502. 

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

  504. {

  505. #if JACKBRIDGE_DUMMY

  506. #elif JACKBRIDGE_DIRECT

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

  508. #else

  509.     if (bridge.client_open_ptr != nullptr)

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

  511. #endif

  512.     if (status != nullptr)

  513.         *status = JackServerError;

  514.     return nullptr;

  515. }

  516. 

  517. const char* jackbridge_client_rename(jack_client_t* client, const char* new_name)

  518. {

  519. #if JACKBRIDGE_DUMMY

  520. #elif JACKBRIDGE_DIRECT

  521.     return jack_client_rename(client, new_name);

  522. #else

  523.     if (bridge.client_rename_ptr != nullptr)

  524.         return bridge.client_rename_ptr(client, new_name);

  525. #endif

  526.     return nullptr;

  527. }

  528. 

  529. bool jackbridge_client_close(jack_client_t* client)

  530. {

  531. #if JACKBRIDGE_DUMMY

  532. #elif JACKBRIDGE_DIRECT

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

  534. #else

  535.     if (bridge.client_close_ptr != nullptr)

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

  537. #endif

  538.     return false;

  539. }

  540. 

  541. // -----------------------------------------------------------------------------

  542. 

  543. int jackbridge_client_name_size()

  544. {

  545. #if JACKBRIDGE_DUMMY

  546. #elif JACKBRIDGE_DIRECT

  547.     return jack_client_name_size();

  548. #else

  549.     if (bridge.client_name_size_ptr != nullptr)

  550.         return bridge.client_name_size_ptr();

  551. #endif

  552.     return 0;

  553. }

  554. 

  555. char* jackbridge_get_client_name(jack_client_t* client)

  556. {

  557. #if JACKBRIDGE_DUMMY

  558. #elif JACKBRIDGE_DIRECT

  559.     return jack_get_client_name(client);

  560. #else

  561.     if (bridge.get_client_name_ptr != nullptr)

  562.         return bridge.get_client_name_ptr(client);

  563. #endif

  564.     return nullptr;

  565. }

  566. 

  567. // -----------------------------------------------------------------------------

  568. 

  569. bool jackbridge_activate(jack_client_t* client)

  570. {

  571. #if JACKBRIDGE_DUMMY

  572. #elif JACKBRIDGE_DIRECT

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

  574. #else

  575.     if (bridge.activate_ptr != nullptr)

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

  577. #endif

  578.     return false;

  579. }

  580. 

  581. bool jackbridge_deactivate(jack_client_t* client)

  582. {

  583. #if JACKBRIDGE_DUMMY

  584. #elif JACKBRIDGE_DIRECT

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

  586. #else

  587.     if (bridge.deactivate_ptr != nullptr)

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

  589. #endif

  590.     return false;

  591. }

  592. 

  593. // -----------------------------------------------------------------------------

  594. 

  595. int jackbridge_get_client_pid(const char* name)

  596. {

  597. #if JACKBRIDGE_DUMMY

  598. #elif JACKBRIDGE_DIRECT

  599.     return jack_get_client_pid(name);

  600. #else

  601.     if (bridge.get_client_pid_ptr != nullptr)

  602.         return bridge.get_client_pid_ptr(name);

  603. #endif

  604.     return 0;

  605. }

  606. 

  607. bool jackbridge_is_realtime(jack_client_t* client)

  608. {

  609. #if JACKBRIDGE_DUMMY

  610. #elif JACKBRIDGE_DIRECT

  611.     return jack_is_realtime(client);

  612. #else

  613.     if (bridge.is_realtime_ptr != nullptr)

  614.         return bridge.is_realtime_ptr(client);

  615. #endif

  616.     return false;

  617. }

  618. 

  619. // -----------------------------------------------------------------------------

  620. 

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

  622. {

  623. #if JACKBRIDGE_DUMMY

  624. #elif JACKBRIDGE_DIRECT

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

  626. #else

  627.     if (bridge.set_thread_init_callback_ptr != nullptr)

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

  629. #endif

  630.     return false;

  631. }

  632. 

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

  634. {

  635. #if JACKBRIDGE_DUMMY

  636. #elif JACKBRIDGE_DIRECT

  637.     jack_on_shutdown(client, shutdown_callback, arg);

  638. #else

  639.     if (bridge.on_shutdown_ptr != nullptr)

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

  641. #endif

  642. }

  643. 

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

  645. {

  646. #if JACKBRIDGE_DUMMY

  647. #elif JACKBRIDGE_DIRECT

  648.     jack_on_info_shutdown(client, shutdown_callback, arg);

  649. #else

  650.     if (bridge.on_info_shutdown_ptr != nullptr)

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

  652. #endif

  653. }

  654. 

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

  656. {

  657. #if JACKBRIDGE_DUMMY

  658. #elif JACKBRIDGE_DIRECT

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

  660. #else

  661.     if (bridge.set_process_callback_ptr != nullptr)

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

  663. #endif

  664.     return false;

  665. }

  666. 

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

  668. {

  669. #if JACKBRIDGE_DUMMY

  670. #elif JACKBRIDGE_DIRECT

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

  672. #else

  673.     if (bridge.set_freewheel_callback_ptr != nullptr)

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

  675. #endif

  676.     return false;

  677. }

  678. 

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

  680. {

  681. #if JACKBRIDGE_DUMMY

  682. #elif JACKBRIDGE_DIRECT

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

  684. #else

  685.     if (bridge.set_buffer_size_callback_ptr != nullptr)

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

  687. #endif

  688.     return false;

  689. }

  690. 

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

  692. {

  693. #if JACKBRIDGE_DUMMY

  694. #elif JACKBRIDGE_DIRECT

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

  696. #else

  697.     if (bridge.set_sample_rate_callback_ptr != nullptr)

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

  699. #endif

  700.     return false;

  701. }

  702. 

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

  704. {

  705. #if JACKBRIDGE_DUMMY

  706. #elif JACKBRIDGE_DIRECT

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

  708. #else

  709.     if (bridge.set_client_registration_callback_ptr != nullptr)

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

  711. #endif

  712.     return false;

  713. }

  714. 

  715. bool jackbridge_set_client_rename_callback(jack_client_t* client, JackClientRenameCallback rename_callback, void* arg)

  716. {

  717. #if JACKBRIDGE_DUMMY

  718. #elif JACKBRIDGE_DIRECT

  719.     return (jack_set_client_rename_callback(client, registration_callback, arg) == 0);

  720. #else

  721.     if (bridge.set_client_rename_callback_ptr != nullptr)

  722.         return (bridge.set_client_rename_callback_ptr(client, rename_callback, arg) == 0);

  723. #endif

  724.     return false;

  725. }

  726. 

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

  728. {

  729. #if JACKBRIDGE_DUMMY

  730. #elif JACKBRIDGE_DIRECT

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

  732. #else

  733.     if (bridge.set_port_registration_callback_ptr != nullptr)

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

  735. #endif

  736.     return false;

  737. }

  738. 

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

  740. {

  741. #if JACKBRIDGE_DUMMY

  742. #elif JACKBRIDGE_DIRECT

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

  744. #else

  745.     if (bridge.set_port_connect_callback_ptr != nullptr)

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

  747. #endif

  748.     return false;

  749. }

  750. 

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

  752. {

  753. #if JACKBRIDGE_DUMMY

  754. #elif JACKBRIDGE_DIRECT

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

  756. #else

  757.     if (bridge.set_port_rename_callback_ptr != nullptr)

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

  759. #endif

  760.     return false;

  761. }

  762. 

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

  764. {

  765. #if JACKBRIDGE_DUMMY

  766. #elif JACKBRIDGE_DIRECT

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

  768. #else

  769.     if (bridge.set_xrun_callback_ptr != nullptr)

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

  771. #endif

  772.     return false;

  773. }

  774. 

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

  776. {

  777. #if JACKBRIDGE_DUMMY

  778. #elif JACKBRIDGE_DIRECT

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

  780. #else

  781.     if (bridge.set_latency_callback_ptr != nullptr)

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

  783. #endif

  784.     return false;

  785. }

  786. 

  787. // -----------------------------------------------------------------------------

  788. 

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

  790. {

  791. #if JACKBRIDGE_DUMMY

  792. #elif JACKBRIDGE_DIRECT

  793.     return jack_set_freewheel(client, onoff);

  794. #else

  795.     if (bridge.set_freewheel_ptr != nullptr)

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

  797. #endif

  798.     return false;

  799. }

  800. 

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

  802. {

  803. #if JACKBRIDGE_DUMMY

  804. #elif JACKBRIDGE_DIRECT

  805.     return jack_set_buffer_size(client, nframes);

  806. #else

  807.     if (bridge.set_buffer_size_ptr != nullptr)

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

  809. #endif

  810.     return false;

  811. }

  812. 

  813. // -----------------------------------------------------------------------------

  814. 

  815. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  816. {

  817. #if JACKBRIDGE_DUMMY

  818. #elif JACKBRIDGE_DIRECT

  819.     return jack_get_sample_rate(client);

  820. #else

  821.     if (bridge.get_sample_rate_ptr != nullptr)

  822.         return bridge.get_sample_rate_ptr(client);

  823. #endif

  824.     return 0;

  825. }

  826. 

  827. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  828. {

  829. #if JACKBRIDGE_DUMMY

  830. #elif JACKBRIDGE_DIRECT

  831.     return jack_get_buffer_size(client);

  832. #else

  833.     if (bridge.get_buffer_size_ptr != nullptr)

  834.         return bridge.get_buffer_size_ptr(client);

  835. #endif

  836.     return 0;

  837. }

  838. 

  839. float jackbridge_cpu_load(jack_client_t* client)

  840. {

  841. #if JACKBRIDGE_DUMMY

  842. #elif JACKBRIDGE_DIRECT

  843.     return jack_cpu_load(client);

  844. #else

  845.     if (bridge.cpu_load_ptr != nullptr)

  846.         return bridge.cpu_load_ptr(client);

  847. #endif

  848.     return 0.0f;

  849. }

  850. 

  851. // -----------------------------------------------------------------------------

  852. 

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

  854. {

  855. #if JACKBRIDGE_DUMMY

  856. #elif JACKBRIDGE_DIRECT

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

  858. #else

  859.     if (bridge.port_register_ptr != nullptr)

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

  861. #endif

  862.     return nullptr;

  863. }

  864. 

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

  866. {

  867. #if JACKBRIDGE_DUMMY

  868. #elif JACKBRIDGE_DIRECT

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

  870. #else

  871.     if (bridge.port_unregister_ptr != nullptr)

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

  873. #endif

  874.     return false;

  875. }

  876. 

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

  878. {

  879. #if JACKBRIDGE_DUMMY

  880. #elif JACKBRIDGE_DIRECT

  881.     return jack_port_get_buffer(port, nframes);

  882. #else

  883.     if (bridge.port_get_buffer_ptr != nullptr)

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

  885. #endif

  886.     return nullptr;

  887. }

  888. 

  889. // -----------------------------------------------------------------------------

  890. 

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

  892. {

  893. #if JACKBRIDGE_DUMMY

  894. #elif JACKBRIDGE_DIRECT

  895.     return jack_port_name(port);

  896. #else

  897.     if (bridge.port_name_ptr != nullptr)

  898.         return bridge.port_name_ptr(port);

  899. #endif

  900.     return nullptr;

  901. }

  902. 

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

  904. {

  905. #if JACKBRIDGE_DUMMY

  906. #elif JACKBRIDGE_DIRECT

  907.     return jack_port_short_name(port);

  908. #else

  909.     if (bridge.port_short_name_ptr != nullptr)

  910.         return bridge.port_short_name_ptr(port);

  911. #endif

  912.     return nullptr;

  913. }

  914. 

  915. int jackbridge_port_flags(const jack_port_t* port)

  916. {

  917. #if JACKBRIDGE_DUMMY

  918. #elif JACKBRIDGE_DIRECT

  919.     return jack_port_flags(port);

  920. #else

  921.     if (bridge.port_flags_ptr != nullptr)

  922.         return bridge.port_flags_ptr(port);

  923. #endif

  924.     return 0x0;

  925. }

  926. 

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

  928. {

  929. #if JACKBRIDGE_DUMMY

  930. #elif JACKBRIDGE_DIRECT

  931.     return jack_port_type(port);

  932. #else

  933.     if (bridge.port_type_ptr != nullptr)

  934.         return bridge.port_type_ptr(port);

  935. #endif

  936.     return nullptr;

  937. }

  938. 

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

  940. {

  941. #if JACKBRIDGE_DUMMY

  942. #elif JACKBRIDGE_DIRECT

  943.     return jack_port_is_mine(client, port);

  944. #else

  945.     if (bridge.port_is_mine_ptr != nullptr)

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

  947. #endif

  948.     return false;

  949. }

  950. 

  951. bool jackbridge_port_connected(const jack_port_t* port)

  952. {

  953. #if JACKBRIDGE_DUMMY

  954. #elif JACKBRIDGE_DIRECT

  955.     return jack_port_connected(port);

  956. #else

  957.     if (bridge.port_connected_ptr != nullptr)

  958.         return bridge.port_connected_ptr(port);

  959. #endif

  960.     return false;

  961. }

  962. 

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

  964. {

  965. #if JACKBRIDGE_DUMMY

  966. #elif JACKBRIDGE_DIRECT

  967.     return jack_port_connected_to(port, port_name);

  968. #else

  969.     if (bridge.port_connected_to_ptr != nullptr)

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

  971. #endif

  972.     return false;

  973. }

  974. 

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

  976. {

  977. #if JACKBRIDGE_DUMMY

  978. #elif JACKBRIDGE_DIRECT

  979.     return jack_port_get_connections(port);

  980. #else

  981.     if (bridge.port_get_connections_ptr != nullptr)

  982.         return bridge.port_get_connections_ptr(port);

  983. #endif

  984.     return nullptr;

  985. }

  986. 

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

  988. {

  989. #if JACKBRIDGE_DUMMY

  990. #elif JACKBRIDGE_DIRECT

  991.     return jack_port_get_all_connections(client, port);

  992. #else

  993.     if (bridge.port_get_all_connections_ptr != nullptr)

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

  995. #endif

  996.     return nullptr;

  997. }

  998. 

  999. // -----------------------------------------------------------------------------

  1000. 

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

  1002. {

  1003. #if JACKBRIDGE_DUMMY

  1004. #elif JACKBRIDGE_DIRECT

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

  1006. #else

  1007.     if (bridge.port_set_name_ptr != nullptr)

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

  1009. #endif

  1010.     return false;

  1011. }

  1012. 

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

  1014. {

  1015. #if JACKBRIDGE_DUMMY

  1016. #elif JACKBRIDGE_DIRECT

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

  1018. #else

  1019.     if (bridge.port_set_alias_ptr != nullptr)

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

  1021. #endif

  1022.     return false;

  1023. }

  1024. 

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

  1026. {

  1027. #if JACKBRIDGE_DUMMY

  1028. #elif JACKBRIDGE_DIRECT

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

  1030. #else

  1031.     if (bridge.port_unset_alias_ptr != nullptr)

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

  1033. #endif

  1034.     return false;

  1035. }

  1036. 

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

  1038. {

  1039. #if JACKBRIDGE_DUMMY

  1040. #elif JACKBRIDGE_DIRECT

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

  1042. #else

  1043.     if (bridge.port_get_aliases_ptr != nullptr)

  1044.         return (bridge.port_get_aliases_ptr(port, aliases) == 0);

  1045. #endif

  1046.     return 0;

  1047. }

  1048. 

  1049. // -----------------------------------------------------------------------------

  1050. 

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

  1052. {

  1053. #if JACKBRIDGE_DUMMY

  1054. #elif JACKBRIDGE_DIRECT

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

  1056. #else

  1057.     if (bridge.port_request_monitor_ptr != nullptr)

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

  1059. #endif

  1060.     return false;

  1061. }

  1062. 

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

  1064. {

  1065. #if JACKBRIDGE_DUMMY

  1066. #elif JACKBRIDGE_DIRECT

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

  1068. #else

  1069.     if (bridge.port_request_monitor_by_name_ptr != nullptr)

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

  1071. #endif

  1072.     return false;

  1073. }

  1074. 

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

  1076. {

  1077. #if JACKBRIDGE_DUMMY

  1078. #elif JACKBRIDGE_DIRECT

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

  1080. #else

  1081.     if (bridge.port_ensure_monitor_ptr != nullptr)

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

  1083. #endif

  1084.     return false;

  1085. }

  1086. 

  1087. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1088. {

  1089. #if JACKBRIDGE_DUMMY

  1090. #elif JACKBRIDGE_DIRECT

  1091.     return jack_port_monitoring_input(port);

  1092. #else

  1093.     if (bridge.port_monitoring_input_ptr != nullptr)

  1094.         return bridge.port_monitoring_input_ptr(port);

  1095. #endif

  1096.     return false;

  1097. }

  1098. 

  1099. // -----------------------------------------------------------------------------

  1100. 

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

  1102. {

  1103. #if JACKBRIDGE_DUMMY

  1104. #elif JACKBRIDGE_DIRECT

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

  1106. #else

  1107.     if (bridge.connect_ptr != nullptr)

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

  1109. #endif

  1110.     return false;

  1111. }

  1112. 

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

  1114. {

  1115. #if JACKBRIDGE_DUMMY

  1116. #elif JACKBRIDGE_DIRECT

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

  1118. #else

  1119.     if (bridge.disconnect_ptr != nullptr)

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

  1121. #endif

  1122.     return false;

  1123. }

  1124. 

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

  1126. {

  1127. #if JACKBRIDGE_DUMMY

  1128. #elif JACKBRIDGE_DIRECT

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

  1130. #else

  1131.     if (bridge.port_disconnect_ptr != nullptr)

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

  1133. #endif

  1134.     return false;

  1135. }

  1136. 

  1137. // -----------------------------------------------------------------------------

  1138. 

  1139. int jackbridge_port_name_size()

  1140. {

  1141. #if JACKBRIDGE_DUMMY

  1142. #elif JACKBRIDGE_DIRECT

  1143.     return jack_port_name_size();

  1144. #else

  1145.     if (bridge.port_name_size_ptr != nullptr)

  1146.         return bridge.port_name_size_ptr();

  1147. #endif

  1148.     return 0;

  1149. }

  1150. 

  1151. int jackbridge_port_type_size()

  1152. {

  1153. #if JACKBRIDGE_DUMMY

  1154. #elif JACKBRIDGE_DIRECT

  1155.     return jack_port_type_size();

  1156. #else

  1157.     if (bridge.port_type_size_ptr != nullptr)

  1158.         return bridge.port_type_size_ptr();

  1159. #endif

  1160.     return 0;

  1161. }

  1162. 

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

  1164. {

  1165. #if JACKBRIDGE_DUMMY

  1166. #elif JACKBRIDGE_DIRECT

  1167.     return jack_port_type_get_buffer_size(client, port_type);

  1168. #else

  1169.     if (bridge.port_type_get_buffer_size_ptr != nullptr)

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

  1171. #endif

  1172.     return 0;

  1173. }

  1174. 

  1175. // -----------------------------------------------------------------------------

  1176. 

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

  1178. {

  1179. #if JACKBRIDGE_DUMMY

  1180. #elif JACKBRIDGE_DIRECT

  1181.     jack_port_get_latency_range(port, mode, range);

  1182. #else

  1183.     if (bridge.port_get_latency_range_ptr != nullptr)

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

  1185. #endif

  1186. }

  1187. 

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

  1189. {

  1190. #if JACKBRIDGE_DUMMY

  1191. #elif JACKBRIDGE_DIRECT

  1192.     jack_port_set_latency_range(port, mode, range);

  1193. #else

  1194.     if (bridge.port_set_latency_range_ptr != nullptr)

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

  1196. #endif

  1197. }

  1198. 

  1199. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1200. {

  1201. #if JACKBRIDGE_DUMMY

  1202. #elif JACKBRIDGE_DIRECT

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

  1204. #else

  1205.     if (bridge.recompute_total_latencies_ptr != nullptr)

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

  1207. #endif

  1208.     return false;

  1209. }

  1210. 

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

  1212. 

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

  1214. {

  1215. #if JACKBRIDGE_DUMMY

  1216. #elif JACKBRIDGE_DIRECT

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

  1218. #else

  1219.     if (bridge.get_ports_ptr != nullptr)

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

  1221. #endif

  1222.     return nullptr;

  1223. }

  1224. 

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

  1226. {

  1227. #if JACKBRIDGE_DUMMY

  1228. #elif JACKBRIDGE_DIRECT

  1229.     return jack_port_by_name(client, port_name);

  1230. #else

  1231.     if (bridge.port_by_name_ptr != nullptr)

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

  1233. #endif

  1234.     return nullptr;

  1235. }

  1236. 

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

  1238. {

  1239. #if JACKBRIDGE_DUMMY

  1240. #elif JACKBRIDGE_DIRECT

  1241.     return jack_port_by_id(client, port_id);

  1242. #else

  1243.     if (bridge.port_by_id_ptr != nullptr)

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

  1245. #endif

  1246.     return nullptr;

  1247. }

  1248. 

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

  1250. 

  1251. void jackbridge_free(void* ptr)

  1252. {

  1253. #if JACKBRIDGE_DUMMY

  1254. #elif JACKBRIDGE_DIRECT

  1255.     return jack_free(ptr);

  1256. #else

  1257.     if (bridge.free_ptr != nullptr)

  1258.         return bridge.free_ptr(ptr);

  1259. 

  1260.     // just in case

  1261.     std::free(ptr);

  1262. #endif

  1263. }

  1264. 

  1265. // -----------------------------------------------------------------------------

  1266. 

  1267. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1268. {

  1269. #if JACKBRIDGE_DUMMY

  1270. #elif JACKBRIDGE_DIRECT

  1271.     return jack_midi_get_event_count(port_buffer);

  1272. #else

  1273.     if (bridge.midi_get_event_count_ptr != nullptr)

  1274.         return bridge.midi_get_event_count_ptr(port_buffer);

  1275. #endif

  1276.     return 0;

  1277. }

  1278. 

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

  1280. {

  1281. #if JACKBRIDGE_DUMMY

  1282. #elif JACKBRIDGE_DIRECT

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

  1284. #else

  1285.     if (bridge.midi_event_get_ptr != nullptr)

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

  1287. #endif

  1288.     return false;

  1289. }

  1290. 

  1291. void jackbridge_midi_clear_buffer(void* port_buffer)

  1292. {

  1293. #if JACKBRIDGE_DUMMY

  1294. #elif JACKBRIDGE_DIRECT

  1295.     jack_midi_clear_buffer(port_buffer);

  1296. #else

  1297.     if (bridge.midi_clear_buffer_ptr != nullptr)

  1298.         bridge.midi_clear_buffer_ptr(port_buffer);

  1299. #endif

  1300. }

  1301. 

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

  1303. {

  1304. #if JACKBRIDGE_DUMMY

  1305. #elif JACKBRIDGE_DIRECT

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

  1307. #else

  1308.     if (bridge.midi_event_write_ptr != nullptr)

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

  1310. #endif

  1311.     return false;

  1312. }

  1313. 

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

  1315. {

  1316. #if JACKBRIDGE_DUMMY

  1317. #elif JACKBRIDGE_DIRECT

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

  1319. #else

  1320.     if (bridge.midi_event_reserve_ptr != nullptr)

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

  1322. #endif

  1323.     return nullptr;

  1324. }

  1325. 

  1326. // -----------------------------------------------------------------------------

  1327. 

  1328. bool jackbridge_release_timebase(jack_client_t* client)

  1329. {

  1330. #if JACKBRIDGE_DUMMY

  1331. #elif JACKBRIDGE_DIRECT

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

  1333. #else

  1334.     if (bridge.release_timebase_ptr != nullptr)

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

  1336. #endif

  1337.     return false;

  1338. }

  1339. 

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

  1341. {

  1342. #if JACKBRIDGE_DUMMY

  1343. #elif JACKBRIDGE_DIRECT

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

  1345. #else

  1346.     if (bridge.set_sync_callback_ptr != nullptr)

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

  1348. #endif

  1349.     return false;

  1350. }

  1351. 

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

  1353. {

  1354. #if JACKBRIDGE_DUMMY

  1355. #elif JACKBRIDGE_DIRECT

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

  1357. #else

  1358.     if (bridge.set_sync_timeout_ptr != nullptr)

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

  1360. #endif

  1361.     return false;

  1362. }

  1363. 

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

  1365. {

  1366. #if JACKBRIDGE_DUMMY

  1367. #elif JACKBRIDGE_DIRECT

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

  1369. #else

  1370.     if (bridge.set_timebase_callback_ptr != nullptr)

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

  1372. #endif

  1373.     return false;

  1374. }

  1375. 

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

  1377. {

  1378. #if JACKBRIDGE_DUMMY

  1379. #elif JACKBRIDGE_DIRECT

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

  1381. #else

  1382.     if (bridge.transport_locate_ptr != nullptr)

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

  1384. #endif

  1385.     return false;

  1386. }

  1387. 

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

  1389. {

  1390. #if JACKBRIDGE_DUMMY

  1391. #elif JACKBRIDGE_DIRECT

  1392.     return jack_transport_query(client, pos);

  1393. #else

  1394.     if (bridge.transport_query_ptr != nullptr)

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

  1396. #endif

  1397.     if (pos != nullptr)

  1398.     {

  1399.         // invalidate

  1400.         pos->unique_1 = 0;

  1401.         pos->unique_2 = 1;

  1402.     }

  1403.     return JackTransportStopped;

  1404. }

  1405. 

  1406. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1407. {

  1408. #if JACKBRIDGE_DUMMY

  1409. #elif JACKBRIDGE_DIRECT

  1410.     return jack_get_current_transport_frame(client);

  1411. #else

  1412.     if (bridge.get_current_transport_frame_ptr != nullptr)

  1413.         return bridge.get_current_transport_frame_ptr(client);

  1414. #endif

  1415.     return 0;

  1416. }

  1417. 

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

  1419. {

  1420. #if JACKBRIDGE_DUMMY

  1421. #elif JACKBRIDGE_DIRECT

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

  1423. #else

  1424.     if (bridge.transport_reposition_ptr != nullptr)

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

  1426. #endif

  1427.     return false;

  1428. }

  1429. 

  1430. void jackbridge_transport_start(jack_client_t* client)

  1431. {

  1432. #if JACKBRIDGE_DUMMY

  1433. #elif JACKBRIDGE_DIRECT

  1434.     jack_transport_start(client);

  1435. #else

  1436.     if (bridge.transport_start_ptr != nullptr)

  1437.         bridge.transport_start_ptr(client);

  1438. #endif

  1439. }

  1440. 

  1441. void jackbridge_transport_stop(jack_client_t* client)

  1442. {

  1443. #if JACKBRIDGE_DUMMY

  1444. #elif JACKBRIDGE_DIRECT

  1445.     jack_transport_stop(client);

  1446. #else

  1447.     if (bridge.transport_stop_ptr != nullptr)

  1448.         bridge.transport_stop_ptr(client);

  1449. #endif

  1450. }

  1451. 

  1452. // -----------------------------------------------------------------------------

  1453. 

  1454. bool jackbridge_custom_publish_data(jack_client_t* client, const char* key, const void* data, size_t size)

  1455. {

  1456. #if JACKBRIDGE_DUMMY

  1457. #elif JACKBRIDGE_DIRECT

  1458.     return (jack_custom_publish_data(client, key, data, size) == 0);

  1459. #else

  1460.     if (bridge.custom_publish_data_ptr != nullptr)

  1461.         return (bridge.custom_publish_data_ptr(client, key, data, size) == 0);

  1462. #endif

  1463.     return false;

  1464. }

  1465. 

  1466. bool jackbridge_custom_get_data(jack_client_t* client, const char* client_name, const char* key, void** data, size_t* size)

  1467. {

  1468. #if JACKBRIDGE_DUMMY

  1469. #elif JACKBRIDGE_DIRECT

  1470.     return (jack_custom_get_data(client, client_name, key, data, size) == 0);

  1471. #else

  1472.     if (bridge.custom_get_data_ptr != nullptr)

  1473.         return (bridge.custom_get_data_ptr(client, client_name, key, data, size) == 0);

  1474. #endif

  1475.     return false;

  1476. }

  1477. 

  1478. bool jackbridge_custom_unpublish_data(jack_client_t* client, const char* key)

  1479. {

  1480. #if JACKBRIDGE_DUMMY

  1481. #elif JACKBRIDGE_DIRECT

  1482.     return (jack_custom_unpublish_data(client, key) == 0);

  1483. #else

  1484.     if (bridge.custom_unpublish_data_ptr != nullptr)

  1485.         return (bridge.custom_unpublish_data_ptr(client, key) == 0);

  1486. #endif

  1487.     return false;

  1488. }

  1489. 

  1490. bool jackbridge_custom_set_data_appearance_callback(jack_client_t* client, JackCustomDataAppearanceCallback callback, void* arg)

  1491. {

  1492. #if JACKBRIDGE_DUMMY

  1493. #elif JACKBRIDGE_DIRECT

  1494.     return (jack_custom_set_data_appearance_callback(client, callback, arg) == 0);

  1495. #else

  1496.     if (bridge.custom_set_data_appearance_callback_ptr != nullptr)

  1497.         return (bridge.custom_set_data_appearance_callback_ptr(client, callback, arg) == 0);

  1498. #endif

  1499.     return false;

  1500. }

  1501. 

  1502. const char** jackbridge_custom_get_keys(jack_client_t* client, const char* client_name)

  1503. {

  1504. #if JACKBRIDGE_DUMMY

  1505. #elif JACKBRIDGE_DIRECT

  1506.     return jack_custom_get_keys(client, client_name);

  1507. #else

  1508.     if (bridge.custom_get_keys_ptr != nullptr)

  1509.         return bridge.custom_get_keys_ptr(client, client_name);

  1510. #endif

  1511.     return nullptr;

  1512. }

  1513. 

  1514. // -----------------------------------------------------------------------------