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

1518 lines
49KB
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.         {

  461.             lib_close(lib);

  462.             lib = nullptr;

  463.         }

  464.     }

  465. };

  466. 

  467. static JackBridge bridge;

  468. 

  469. #endif // ! JACKBRIDGE_DIRECT

  470. 

  471. // -----------------------------------------------------------------------------

  472. 

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

  474. {

  475. #if JACKBRIDGE_DUMMY

  476. #elif JACKBRIDGE_DIRECT

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

  478. #else

  479.     if (bridge.get_version_ptr != nullptr)

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

  481. #endif

  482.     if (major_ptr != nullptr)

  483.         *major_ptr = 0;

  484.     if (minor_ptr != nullptr)

  485.         *minor_ptr = 0;

  486.     if (micro_ptr != nullptr)

  487.         *micro_ptr = 0;

  488.     if (proto_ptr != nullptr)

  489.         *proto_ptr = 0;

  490. }

  491. 

  492. const char* jackbridge_get_version_string()

  493. {

  494. #if JACKBRIDGE_DUMMY

  495. #elif JACKBRIDGE_DIRECT

  496.     return jack_get_version_string();

  497. #else

  498.     if (bridge.get_version_string_ptr != nullptr)

  499.         return bridge.get_version_string_ptr();

  500. #endif

  501.     return nullptr;

  502. }

  503. 

  504. // -----------------------------------------------------------------------------

  505. 

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

  507. {

  508. #if JACKBRIDGE_DUMMY

  509. #elif JACKBRIDGE_DIRECT

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

  511. #else

  512.     if (bridge.client_open_ptr != nullptr)

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

  514. #endif

  515.     if (status != nullptr)

  516.         *status = JackServerError;

  517.     return nullptr;

  518. }

  519. 

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

  521. {

  522. #if JACKBRIDGE_DUMMY

  523. #elif JACKBRIDGE_DIRECT

  524.     return jack_client_rename(client, new_name);

  525. #else

  526.     if (bridge.client_rename_ptr != nullptr)

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

  528. #endif

  529.     return nullptr;

  530. }

  531. 

  532. bool jackbridge_client_close(jack_client_t* client)

  533. {

  534. #if JACKBRIDGE_DUMMY

  535. #elif JACKBRIDGE_DIRECT

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

  537. #else

  538.     if (bridge.client_close_ptr != nullptr)

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

  540. #endif

  541.     return false;

  542. }

  543. 

  544. // -----------------------------------------------------------------------------

  545. 

  546. int jackbridge_client_name_size()

  547. {

  548. #if JACKBRIDGE_DUMMY

  549. #elif JACKBRIDGE_DIRECT

  550.     return jack_client_name_size();

  551. #else

  552.     if (bridge.client_name_size_ptr != nullptr)

  553.         return bridge.client_name_size_ptr();

  554. #endif

  555.     return 0;

  556. }

  557. 

  558. char* jackbridge_get_client_name(jack_client_t* client)

  559. {

  560. #if JACKBRIDGE_DUMMY

  561. #elif JACKBRIDGE_DIRECT

  562.     return jack_get_client_name(client);

  563. #else

  564.     if (bridge.get_client_name_ptr != nullptr)

  565.         return bridge.get_client_name_ptr(client);

  566. #endif

  567.     return nullptr;

  568. }

  569. 

  570. // -----------------------------------------------------------------------------

  571. 

  572. bool jackbridge_activate(jack_client_t* client)

  573. {

  574. #if JACKBRIDGE_DUMMY

  575. #elif JACKBRIDGE_DIRECT

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

  577. #else

  578.     if (bridge.activate_ptr != nullptr)

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

  580. #endif

  581.     return false;

  582. }

  583. 

  584. bool jackbridge_deactivate(jack_client_t* client)

  585. {

  586. #if JACKBRIDGE_DUMMY

  587. #elif JACKBRIDGE_DIRECT

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

  589. #else

  590.     if (bridge.deactivate_ptr != nullptr)

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

  592. #endif

  593.     return false;

  594. }

  595. 

  596. // -----------------------------------------------------------------------------

  597. 

  598. int jackbridge_get_client_pid(const char* name)

  599. {

  600. #if JACKBRIDGE_DUMMY

  601. #elif JACKBRIDGE_DIRECT

  602.     return jack_get_client_pid(name);

  603. #else

  604.     if (bridge.get_client_pid_ptr != nullptr)

  605.         return bridge.get_client_pid_ptr(name);

  606. #endif

  607.     return 0;

  608. }

  609. 

  610. bool jackbridge_is_realtime(jack_client_t* client)

  611. {

  612. #if JACKBRIDGE_DUMMY

  613. #elif JACKBRIDGE_DIRECT

  614.     return jack_is_realtime(client);

  615. #else

  616.     if (bridge.is_realtime_ptr != nullptr)

  617.         return bridge.is_realtime_ptr(client);

  618. #endif

  619.     return false;

  620. }

  621. 

  622. // -----------------------------------------------------------------------------

  623. 

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

  625. {

  626. #if JACKBRIDGE_DUMMY

  627. #elif JACKBRIDGE_DIRECT

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

  629. #else

  630.     if (bridge.set_thread_init_callback_ptr != nullptr)

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

  632. #endif

  633.     return false;

  634. }

  635. 

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

  637. {

  638. #if JACKBRIDGE_DUMMY

  639. #elif JACKBRIDGE_DIRECT

  640.     jack_on_shutdown(client, shutdown_callback, arg);

  641. #else

  642.     if (bridge.on_shutdown_ptr != nullptr)

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

  644. #endif

  645. }

  646. 

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

  648. {

  649. #if JACKBRIDGE_DUMMY

  650. #elif JACKBRIDGE_DIRECT

  651.     jack_on_info_shutdown(client, shutdown_callback, arg);

  652. #else

  653.     if (bridge.on_info_shutdown_ptr != nullptr)

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

  655. #endif

  656. }

  657. 

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

  659. {

  660. #if JACKBRIDGE_DUMMY

  661. #elif JACKBRIDGE_DIRECT

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

  663. #else

  664.     if (bridge.set_process_callback_ptr != nullptr)

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

  666. #endif

  667.     return false;

  668. }

  669. 

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

  671. {

  672. #if JACKBRIDGE_DUMMY

  673. #elif JACKBRIDGE_DIRECT

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

  675. #else

  676.     if (bridge.set_freewheel_callback_ptr != nullptr)

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

  678. #endif

  679.     return false;

  680. }

  681. 

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

  683. {

  684. #if JACKBRIDGE_DUMMY

  685. #elif JACKBRIDGE_DIRECT

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

  687. #else

  688.     if (bridge.set_buffer_size_callback_ptr != nullptr)

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

  690. #endif

  691.     return false;

  692. }

  693. 

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

  695. {

  696. #if JACKBRIDGE_DUMMY

  697. #elif JACKBRIDGE_DIRECT

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

  699. #else

  700.     if (bridge.set_sample_rate_callback_ptr != nullptr)

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

  702. #endif

  703.     return false;

  704. }

  705. 

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

  707. {

  708. #if JACKBRIDGE_DUMMY

  709. #elif JACKBRIDGE_DIRECT

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

  711. #else

  712.     if (bridge.set_client_registration_callback_ptr != nullptr)

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

  714. #endif

  715.     return false;

  716. }

  717. 

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

  719. {

  720. #if JACKBRIDGE_DUMMY

  721. #elif JACKBRIDGE_DIRECT

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

  723. #else

  724.     if (bridge.set_client_rename_callback_ptr != nullptr)

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

  726. #endif

  727.     return false;

  728. }

  729. 

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

  731. {

  732. #if JACKBRIDGE_DUMMY

  733. #elif JACKBRIDGE_DIRECT

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

  735. #else

  736.     if (bridge.set_port_registration_callback_ptr != nullptr)

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

  738. #endif

  739.     return false;

  740. }

  741. 

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

  743. {

  744. #if JACKBRIDGE_DUMMY

  745. #elif JACKBRIDGE_DIRECT

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

  747. #else

  748.     if (bridge.set_port_connect_callback_ptr != nullptr)

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

  750. #endif

  751.     return false;

  752. }

  753. 

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

  755. {

  756. #if JACKBRIDGE_DUMMY

  757. #elif JACKBRIDGE_DIRECT

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

  759. #else

  760.     if (bridge.set_port_rename_callback_ptr != nullptr)

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

  762. #endif

  763.     return false;

  764. }

  765. 

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

  767. {

  768. #if JACKBRIDGE_DUMMY

  769. #elif JACKBRIDGE_DIRECT

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

  771. #else

  772.     if (bridge.set_xrun_callback_ptr != nullptr)

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

  774. #endif

  775.     return false;

  776. }

  777. 

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

  779. {

  780. #if JACKBRIDGE_DUMMY

  781. #elif JACKBRIDGE_DIRECT

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

  783. #else

  784.     if (bridge.set_latency_callback_ptr != nullptr)

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

  786. #endif

  787.     return false;

  788. }

  789. 

  790. // -----------------------------------------------------------------------------

  791. 

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

  793. {

  794. #if JACKBRIDGE_DUMMY

  795. #elif JACKBRIDGE_DIRECT

  796.     return jack_set_freewheel(client, onoff);

  797. #else

  798.     if (bridge.set_freewheel_ptr != nullptr)

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

  800. #endif

  801.     return false;

  802. }

  803. 

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

  805. {

  806. #if JACKBRIDGE_DUMMY

  807. #elif JACKBRIDGE_DIRECT

  808.     return jack_set_buffer_size(client, nframes);

  809. #else

  810.     if (bridge.set_buffer_size_ptr != nullptr)

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

  812. #endif

  813.     return false;

  814. }

  815. 

  816. // -----------------------------------------------------------------------------

  817. 

  818. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  819. {

  820. #if JACKBRIDGE_DUMMY

  821. #elif JACKBRIDGE_DIRECT

  822.     return jack_get_sample_rate(client);

  823. #else

  824.     if (bridge.get_sample_rate_ptr != nullptr)

  825.         return bridge.get_sample_rate_ptr(client);

  826. #endif

  827.     return 0;

  828. }

  829. 

  830. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  831. {

  832. #if JACKBRIDGE_DUMMY

  833. #elif JACKBRIDGE_DIRECT

  834.     return jack_get_buffer_size(client);

  835. #else

  836.     if (bridge.get_buffer_size_ptr != nullptr)

  837.         return bridge.get_buffer_size_ptr(client);

  838. #endif

  839.     return 0;

  840. }

  841. 

  842. float jackbridge_cpu_load(jack_client_t* client)

  843. {

  844. #if JACKBRIDGE_DUMMY

  845. #elif JACKBRIDGE_DIRECT

  846.     return jack_cpu_load(client);

  847. #else

  848.     if (bridge.cpu_load_ptr != nullptr)

  849.         return bridge.cpu_load_ptr(client);

  850. #endif

  851.     return 0.0f;

  852. }

  853. 

  854. // -----------------------------------------------------------------------------

  855. 

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

  857. {

  858. #if JACKBRIDGE_DUMMY

  859. #elif JACKBRIDGE_DIRECT

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

  861. #else

  862.     if (bridge.port_register_ptr != nullptr)

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

  864. #endif

  865.     return nullptr;

  866. }

  867. 

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

  869. {

  870. #if JACKBRIDGE_DUMMY

  871. #elif JACKBRIDGE_DIRECT

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

  873. #else

  874.     if (bridge.port_unregister_ptr != nullptr)

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

  876. #endif

  877.     return false;

  878. }

  879. 

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

  881. {

  882. #if JACKBRIDGE_DUMMY

  883. #elif JACKBRIDGE_DIRECT

  884.     return jack_port_get_buffer(port, nframes);

  885. #else

  886.     if (bridge.port_get_buffer_ptr != nullptr)

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

  888. #endif

  889.     return nullptr;

  890. }

  891. 

  892. // -----------------------------------------------------------------------------

  893. 

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

  895. {

  896. #if JACKBRIDGE_DUMMY

  897. #elif JACKBRIDGE_DIRECT

  898.     return jack_port_name(port);

  899. #else

  900.     if (bridge.port_name_ptr != nullptr)

  901.         return bridge.port_name_ptr(port);

  902. #endif

  903.     return nullptr;

  904. }

  905. 

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

  907. {

  908. #if JACKBRIDGE_DUMMY

  909. #elif JACKBRIDGE_DIRECT

  910.     return jack_port_short_name(port);

  911. #else

  912.     if (bridge.port_short_name_ptr != nullptr)

  913.         return bridge.port_short_name_ptr(port);

  914. #endif

  915.     return nullptr;

  916. }

  917. 

  918. int jackbridge_port_flags(const jack_port_t* port)

  919. {

  920. #if JACKBRIDGE_DUMMY

  921. #elif JACKBRIDGE_DIRECT

  922.     return jack_port_flags(port);

  923. #else

  924.     if (bridge.port_flags_ptr != nullptr)

  925.         return bridge.port_flags_ptr(port);

  926. #endif

  927.     return 0x0;

  928. }

  929. 

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

  931. {

  932. #if JACKBRIDGE_DUMMY

  933. #elif JACKBRIDGE_DIRECT

  934.     return jack_port_type(port);

  935. #else

  936.     if (bridge.port_type_ptr != nullptr)

  937.         return bridge.port_type_ptr(port);

  938. #endif

  939.     return nullptr;

  940. }

  941. 

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

  943. {

  944. #if JACKBRIDGE_DUMMY

  945. #elif JACKBRIDGE_DIRECT

  946.     return jack_port_is_mine(client, port);

  947. #else

  948.     if (bridge.port_is_mine_ptr != nullptr)

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

  950. #endif

  951.     return false;

  952. }

  953. 

  954. bool jackbridge_port_connected(const jack_port_t* port)

  955. {

  956. #if JACKBRIDGE_DUMMY

  957. #elif JACKBRIDGE_DIRECT

  958.     return jack_port_connected(port);

  959. #else

  960.     if (bridge.port_connected_ptr != nullptr)

  961.         return bridge.port_connected_ptr(port);

  962. #endif

  963.     return false;

  964. }

  965. 

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

  967. {

  968. #if JACKBRIDGE_DUMMY

  969. #elif JACKBRIDGE_DIRECT

  970.     return jack_port_connected_to(port, port_name);

  971. #else

  972.     if (bridge.port_connected_to_ptr != nullptr)

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

  974. #endif

  975.     return false;

  976. }

  977. 

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

  979. {

  980. #if JACKBRIDGE_DUMMY

  981. #elif JACKBRIDGE_DIRECT

  982.     return jack_port_get_connections(port);

  983. #else

  984.     if (bridge.port_get_connections_ptr != nullptr)

  985.         return bridge.port_get_connections_ptr(port);

  986. #endif

  987.     return nullptr;

  988. }

  989. 

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

  991. {

  992. #if JACKBRIDGE_DUMMY

  993. #elif JACKBRIDGE_DIRECT

  994.     return jack_port_get_all_connections(client, port);

  995. #else

  996.     if (bridge.port_get_all_connections_ptr != nullptr)

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

  998. #endif

  999.     return nullptr;

  1000. }

  1001. 

  1002. // -----------------------------------------------------------------------------

  1003. 

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

  1005. {

  1006. #if JACKBRIDGE_DUMMY

  1007. #elif JACKBRIDGE_DIRECT

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

  1009. #else

  1010.     if (bridge.port_set_name_ptr != nullptr)

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

  1012. #endif

  1013.     return false;

  1014. }

  1015. 

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

  1017. {

  1018. #if JACKBRIDGE_DUMMY

  1019. #elif JACKBRIDGE_DIRECT

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

  1021. #else

  1022.     if (bridge.port_set_alias_ptr != nullptr)

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

  1024. #endif

  1025.     return false;

  1026. }

  1027. 

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

  1029. {

  1030. #if JACKBRIDGE_DUMMY

  1031. #elif JACKBRIDGE_DIRECT

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

  1033. #else

  1034.     if (bridge.port_unset_alias_ptr != nullptr)

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

  1036. #endif

  1037.     return false;

  1038. }

  1039. 

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

  1041. {

  1042. #if JACKBRIDGE_DUMMY

  1043. #elif JACKBRIDGE_DIRECT

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

  1045. #else

  1046.     if (bridge.port_get_aliases_ptr != nullptr)

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

  1048. #endif

  1049.     return 0;

  1050. }

  1051. 

  1052. // -----------------------------------------------------------------------------

  1053. 

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

  1055. {

  1056. #if JACKBRIDGE_DUMMY

  1057. #elif JACKBRIDGE_DIRECT

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

  1059. #else

  1060.     if (bridge.port_request_monitor_ptr != nullptr)

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

  1062. #endif

  1063.     return false;

  1064. }

  1065. 

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

  1067. {

  1068. #if JACKBRIDGE_DUMMY

  1069. #elif JACKBRIDGE_DIRECT

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

  1071. #else

  1072.     if (bridge.port_request_monitor_by_name_ptr != nullptr)

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

  1074. #endif

  1075.     return false;

  1076. }

  1077. 

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

  1079. {

  1080. #if JACKBRIDGE_DUMMY

  1081. #elif JACKBRIDGE_DIRECT

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

  1083. #else

  1084.     if (bridge.port_ensure_monitor_ptr != nullptr)

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

  1086. #endif

  1087.     return false;

  1088. }

  1089. 

  1090. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1091. {

  1092. #if JACKBRIDGE_DUMMY

  1093. #elif JACKBRIDGE_DIRECT

  1094.     return jack_port_monitoring_input(port);

  1095. #else

  1096.     if (bridge.port_monitoring_input_ptr != nullptr)

  1097.         return bridge.port_monitoring_input_ptr(port);

  1098. #endif

  1099.     return false;

  1100. }

  1101. 

  1102. // -----------------------------------------------------------------------------

  1103. 

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

  1105. {

  1106. #if JACKBRIDGE_DUMMY

  1107. #elif JACKBRIDGE_DIRECT

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

  1109. #else

  1110.     if (bridge.connect_ptr != nullptr)

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

  1112. #endif

  1113.     return false;

  1114. }

  1115. 

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

  1117. {

  1118. #if JACKBRIDGE_DUMMY

  1119. #elif JACKBRIDGE_DIRECT

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

  1121. #else

  1122.     if (bridge.disconnect_ptr != nullptr)

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

  1124. #endif

  1125.     return false;

  1126. }

  1127. 

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

  1129. {

  1130. #if JACKBRIDGE_DUMMY

  1131. #elif JACKBRIDGE_DIRECT

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

  1133. #else

  1134.     if (bridge.port_disconnect_ptr != nullptr)

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

  1136. #endif

  1137.     return false;

  1138. }

  1139. 

  1140. // -----------------------------------------------------------------------------

  1141. 

  1142. int jackbridge_port_name_size()

  1143. {

  1144. #if JACKBRIDGE_DUMMY

  1145. #elif JACKBRIDGE_DIRECT

  1146.     return jack_port_name_size();

  1147. #else

  1148.     if (bridge.port_name_size_ptr != nullptr)

  1149.         return bridge.port_name_size_ptr();

  1150. #endif

  1151.     return 0;

  1152. }

  1153. 

  1154. int jackbridge_port_type_size()

  1155. {

  1156. #if JACKBRIDGE_DUMMY

  1157. #elif JACKBRIDGE_DIRECT

  1158.     return jack_port_type_size();

  1159. #else

  1160.     if (bridge.port_type_size_ptr != nullptr)

  1161.         return bridge.port_type_size_ptr();

  1162. #endif

  1163.     return 0;

  1164. }

  1165. 

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

  1167. {

  1168. #if JACKBRIDGE_DUMMY

  1169. #elif JACKBRIDGE_DIRECT

  1170.     return jack_port_type_get_buffer_size(client, port_type);

  1171. #else

  1172.     if (bridge.port_type_get_buffer_size_ptr != nullptr)

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

  1174. #endif

  1175.     return 0;

  1176. }

  1177. 

  1178. // -----------------------------------------------------------------------------

  1179. 

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

  1181. {

  1182. #if JACKBRIDGE_DUMMY

  1183. #elif JACKBRIDGE_DIRECT

  1184.     jack_port_get_latency_range(port, mode, range);

  1185. #else

  1186.     if (bridge.port_get_latency_range_ptr != nullptr)

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

  1188. #endif

  1189. }

  1190. 

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

  1192. {

  1193. #if JACKBRIDGE_DUMMY

  1194. #elif JACKBRIDGE_DIRECT

  1195.     jack_port_set_latency_range(port, mode, range);

  1196. #else

  1197.     if (bridge.port_set_latency_range_ptr != nullptr)

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

  1199. #endif

  1200. }

  1201. 

  1202. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1203. {

  1204. #if JACKBRIDGE_DUMMY

  1205. #elif JACKBRIDGE_DIRECT

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

  1207. #else

  1208.     if (bridge.recompute_total_latencies_ptr != nullptr)

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

  1210. #endif

  1211.     return false;

  1212. }

  1213. 

  1214. // -----------------------------------------------------------------------------

  1215. 

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

  1217. {

  1218. #if JACKBRIDGE_DUMMY

  1219. #elif JACKBRIDGE_DIRECT

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

  1221. #else

  1222.     if (bridge.get_ports_ptr != nullptr)

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

  1224. #endif

  1225.     return nullptr;

  1226. }

  1227. 

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

  1229. {

  1230. #if JACKBRIDGE_DUMMY

  1231. #elif JACKBRIDGE_DIRECT

  1232.     return jack_port_by_name(client, port_name);

  1233. #else

  1234.     if (bridge.port_by_name_ptr != nullptr)

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

  1236. #endif

  1237.     return nullptr;

  1238. }

  1239. 

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

  1241. {

  1242. #if JACKBRIDGE_DUMMY

  1243. #elif JACKBRIDGE_DIRECT

  1244.     return jack_port_by_id(client, port_id);

  1245. #else

  1246.     if (bridge.port_by_id_ptr != nullptr)

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

  1248. #endif

  1249.     return nullptr;

  1250. }

  1251. 

  1252. // -----------------------------------------------------------------------------

  1253. 

  1254. void jackbridge_free(void* ptr)

  1255. {

  1256. #if JACKBRIDGE_DUMMY

  1257. #elif JACKBRIDGE_DIRECT

  1258.     return jack_free(ptr);

  1259. #else

  1260.     if (bridge.free_ptr != nullptr)

  1261.         return bridge.free_ptr(ptr);

  1262. 

  1263.     // just in case

  1264.     std::free(ptr);

  1265. #endif

  1266. }

  1267. 

  1268. // -----------------------------------------------------------------------------

  1269. 

  1270. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1271. {

  1272. #if JACKBRIDGE_DUMMY

  1273. #elif JACKBRIDGE_DIRECT

  1274.     return jack_midi_get_event_count(port_buffer);

  1275. #else

  1276.     if (bridge.midi_get_event_count_ptr != nullptr)

  1277.         return bridge.midi_get_event_count_ptr(port_buffer);

  1278. #endif

  1279.     return 0;

  1280. }

  1281. 

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

  1283. {

  1284. #if JACKBRIDGE_DUMMY

  1285. #elif JACKBRIDGE_DIRECT

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

  1287. #else

  1288.     if (bridge.midi_event_get_ptr != nullptr)

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

  1290. #endif

  1291.     return false;

  1292. }

  1293. 

  1294. void jackbridge_midi_clear_buffer(void* port_buffer)

  1295. {

  1296. #if JACKBRIDGE_DUMMY

  1297. #elif JACKBRIDGE_DIRECT

  1298.     jack_midi_clear_buffer(port_buffer);

  1299. #else

  1300.     if (bridge.midi_clear_buffer_ptr != nullptr)

  1301.         bridge.midi_clear_buffer_ptr(port_buffer);

  1302. #endif

  1303. }

  1304. 

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

  1306. {

  1307. #if JACKBRIDGE_DUMMY

  1308. #elif JACKBRIDGE_DIRECT

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

  1310. #else

  1311.     if (bridge.midi_event_write_ptr != nullptr)

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

  1313. #endif

  1314.     return false;

  1315. }

  1316. 

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

  1318. {

  1319. #if JACKBRIDGE_DUMMY

  1320. #elif JACKBRIDGE_DIRECT

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

  1322. #else

  1323.     if (bridge.midi_event_reserve_ptr != nullptr)

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

  1325. #endif

  1326.     return nullptr;

  1327. }

  1328. 

  1329. // -----------------------------------------------------------------------------

  1330. 

  1331. bool jackbridge_release_timebase(jack_client_t* client)

  1332. {

  1333. #if JACKBRIDGE_DUMMY

  1334. #elif JACKBRIDGE_DIRECT

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

  1336. #else

  1337.     if (bridge.release_timebase_ptr != nullptr)

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

  1339. #endif

  1340.     return false;

  1341. }

  1342. 

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

  1344. {

  1345. #if JACKBRIDGE_DUMMY

  1346. #elif JACKBRIDGE_DIRECT

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

  1348. #else

  1349.     if (bridge.set_sync_callback_ptr != nullptr)

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

  1351. #endif

  1352.     return false;

  1353. }

  1354. 

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

  1356. {

  1357. #if JACKBRIDGE_DUMMY

  1358. #elif JACKBRIDGE_DIRECT

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

  1360. #else

  1361.     if (bridge.set_sync_timeout_ptr != nullptr)

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

  1363. #endif

  1364.     return false;

  1365. }

  1366. 

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

  1368. {

  1369. #if JACKBRIDGE_DUMMY

  1370. #elif JACKBRIDGE_DIRECT

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

  1372. #else

  1373.     if (bridge.set_timebase_callback_ptr != nullptr)

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

  1375. #endif

  1376.     return false;

  1377. }

  1378. 

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

  1380. {

  1381. #if JACKBRIDGE_DUMMY

  1382. #elif JACKBRIDGE_DIRECT

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

  1384. #else

  1385.     if (bridge.transport_locate_ptr != nullptr)

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

  1387. #endif

  1388.     return false;

  1389. }

  1390. 

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

  1392. {

  1393. #if JACKBRIDGE_DUMMY

  1394. #elif JACKBRIDGE_DIRECT

  1395.     return jack_transport_query(client, pos);

  1396. #else

  1397.     if (bridge.transport_query_ptr != nullptr)

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

  1399. #endif

  1400.     if (pos != nullptr)

  1401.     {

  1402.         // invalidate

  1403.         pos->unique_1 = 0;

  1404.         pos->unique_2 = 1;

  1405.     }

  1406.     return JackTransportStopped;

  1407. }

  1408. 

  1409. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1410. {

  1411. #if JACKBRIDGE_DUMMY

  1412. #elif JACKBRIDGE_DIRECT

  1413.     return jack_get_current_transport_frame(client);

  1414. #else

  1415.     if (bridge.get_current_transport_frame_ptr != nullptr)

  1416.         return bridge.get_current_transport_frame_ptr(client);

  1417. #endif

  1418.     return 0;

  1419. }

  1420. 

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

  1422. {

  1423. #if JACKBRIDGE_DUMMY

  1424. #elif JACKBRIDGE_DIRECT

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

  1426. #else

  1427.     if (bridge.transport_reposition_ptr != nullptr)

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

  1429. #endif

  1430.     return false;

  1431. }

  1432. 

  1433. void jackbridge_transport_start(jack_client_t* client)

  1434. {

  1435. #if JACKBRIDGE_DUMMY

  1436. #elif JACKBRIDGE_DIRECT

  1437.     jack_transport_start(client);

  1438. #else

  1439.     if (bridge.transport_start_ptr != nullptr)

  1440.         bridge.transport_start_ptr(client);

  1441. #endif

  1442. }

  1443. 

  1444. void jackbridge_transport_stop(jack_client_t* client)

  1445. {

  1446. #if JACKBRIDGE_DUMMY

  1447. #elif JACKBRIDGE_DIRECT

  1448.     jack_transport_stop(client);

  1449. #else

  1450.     if (bridge.transport_stop_ptr != nullptr)

  1451.         bridge.transport_stop_ptr(client);

  1452. #endif

  1453. }

  1454. 

  1455. // -----------------------------------------------------------------------------

  1456. 

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

  1458. {

  1459. #if JACKBRIDGE_DUMMY

  1460. #elif JACKBRIDGE_DIRECT

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

  1462. #else

  1463.     if (bridge.custom_publish_data_ptr != nullptr)

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

  1465. #endif

  1466.     return false;

  1467. }

  1468. 

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

  1470. {

  1471. #if JACKBRIDGE_DUMMY

  1472. #elif JACKBRIDGE_DIRECT

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

  1474. #else

  1475.     if (bridge.custom_get_data_ptr != nullptr)

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

  1477. #endif

  1478.     return false;

  1479. }

  1480. 

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

  1482. {

  1483. #if JACKBRIDGE_DUMMY

  1484. #elif JACKBRIDGE_DIRECT

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

  1486. #else

  1487.     if (bridge.custom_unpublish_data_ptr != nullptr)

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

  1489. #endif

  1490.     return false;

  1491. }

  1492. 

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

  1494. {

  1495. #if JACKBRIDGE_DUMMY

  1496. #elif JACKBRIDGE_DIRECT

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

  1498. #else

  1499.     if (bridge.custom_set_data_appearance_callback_ptr != nullptr)

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

  1501. #endif

  1502.     return false;

  1503. }

  1504. 

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

  1506. {

  1507. #if JACKBRIDGE_DUMMY

  1508. #elif JACKBRIDGE_DIRECT

  1509.     return jack_custom_get_keys(client, client_name);

  1510. #else

  1511.     if (bridge.custom_get_keys_ptr != nullptr)

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

  1513. #endif

  1514.     return nullptr;

  1515. }

  1516. 

  1517. // -----------------------------------------------------------------------------