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

1522 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. #if 0

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

  522. {

  523. #if JACKBRIDGE_DUMMY

  524. #elif JACKBRIDGE_DIRECT

  525.     return jack_client_rename(client, new_name);

  526. #else

  527.     if (bridge.client_rename_ptr != nullptr)

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

  529. #endif

  530.     return nullptr;

  531. }

  532. #endif

  533. 

  534. bool jackbridge_client_close(jack_client_t* client)

  535. {

  536. #if JACKBRIDGE_DUMMY

  537. #elif JACKBRIDGE_DIRECT

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

  539. #else

  540.     if (bridge.client_close_ptr != nullptr)

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

  542. #endif

  543.     return false;

  544. }

  545. 

  546. // -----------------------------------------------------------------------------

  547. 

  548. int jackbridge_client_name_size()

  549. {

  550. #if JACKBRIDGE_DUMMY

  551. #elif JACKBRIDGE_DIRECT

  552.     return jack_client_name_size();

  553. #else

  554.     if (bridge.client_name_size_ptr != nullptr)

  555.         return bridge.client_name_size_ptr();

  556. #endif

  557.     return 0;

  558. }

  559. 

  560. char* jackbridge_get_client_name(jack_client_t* client)

  561. {

  562. #if JACKBRIDGE_DUMMY

  563. #elif JACKBRIDGE_DIRECT

  564.     return jack_get_client_name(client);

  565. #else

  566.     if (bridge.get_client_name_ptr != nullptr)

  567.         return bridge.get_client_name_ptr(client);

  568. #endif

  569.     return nullptr;

  570. }

  571. 

  572. // -----------------------------------------------------------------------------

  573. 

  574. bool jackbridge_activate(jack_client_t* client)

  575. {

  576. #if JACKBRIDGE_DUMMY

  577. #elif JACKBRIDGE_DIRECT

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

  579. #else

  580.     if (bridge.activate_ptr != nullptr)

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

  582. #endif

  583.     return false;

  584. }

  585. 

  586. bool jackbridge_deactivate(jack_client_t* client)

  587. {

  588. #if JACKBRIDGE_DUMMY

  589. #elif JACKBRIDGE_DIRECT

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

  591. #else

  592.     if (bridge.deactivate_ptr != nullptr)

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

  594. #endif

  595.     return false;

  596. }

  597. 

  598. // -----------------------------------------------------------------------------

  599. 

  600. int jackbridge_get_client_pid(const char* name)

  601. {

  602. #if JACKBRIDGE_DUMMY

  603. #elif JACKBRIDGE_DIRECT

  604.     return jack_get_client_pid(name);

  605. #else

  606.     if (bridge.get_client_pid_ptr != nullptr)

  607.         return bridge.get_client_pid_ptr(name);

  608. #endif

  609.     return 0;

  610. }

  611. 

  612. bool jackbridge_is_realtime(jack_client_t* client)

  613. {

  614. #if JACKBRIDGE_DUMMY

  615. #elif JACKBRIDGE_DIRECT

  616.     return jack_is_realtime(client);

  617. #else

  618.     if (bridge.is_realtime_ptr != nullptr)

  619.         return bridge.is_realtime_ptr(client);

  620. #endif

  621.     return false;

  622. }

  623. 

  624. // -----------------------------------------------------------------------------

  625. 

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

  627. {

  628. #if JACKBRIDGE_DUMMY

  629. #elif JACKBRIDGE_DIRECT

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

  631. #else

  632.     if (bridge.set_thread_init_callback_ptr != nullptr)

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

  634. #endif

  635.     return false;

  636. }

  637. 

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

  639. {

  640. #if JACKBRIDGE_DUMMY

  641. #elif JACKBRIDGE_DIRECT

  642.     jack_on_shutdown(client, shutdown_callback, arg);

  643. #else

  644.     if (bridge.on_shutdown_ptr != nullptr)

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

  646. #endif

  647. }

  648. 

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

  650. {

  651. #if JACKBRIDGE_DUMMY

  652. #elif JACKBRIDGE_DIRECT

  653.     jack_on_info_shutdown(client, shutdown_callback, arg);

  654. #else

  655.     if (bridge.on_info_shutdown_ptr != nullptr)

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

  657. #endif

  658. }

  659. 

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

  661. {

  662. #if JACKBRIDGE_DUMMY

  663. #elif JACKBRIDGE_DIRECT

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

  665. #else

  666.     if (bridge.set_process_callback_ptr != nullptr)

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

  668. #endif

  669.     return false;

  670. }

  671. 

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

  673. {

  674. #if JACKBRIDGE_DUMMY

  675. #elif JACKBRIDGE_DIRECT

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

  677. #else

  678.     if (bridge.set_freewheel_callback_ptr != nullptr)

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

  680. #endif

  681.     return false;

  682. }

  683. 

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

  685. {

  686. #if JACKBRIDGE_DUMMY

  687. #elif JACKBRIDGE_DIRECT

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

  689. #else

  690.     if (bridge.set_buffer_size_callback_ptr != nullptr)

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

  692. #endif

  693.     return false;

  694. }

  695. 

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

  697. {

  698. #if JACKBRIDGE_DUMMY

  699. #elif JACKBRIDGE_DIRECT

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

  701. #else

  702.     if (bridge.set_sample_rate_callback_ptr != nullptr)

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

  704. #endif

  705.     return false;

  706. }

  707. 

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

  709. {

  710. #if JACKBRIDGE_DUMMY

  711. #elif JACKBRIDGE_DIRECT

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

  713. #else

  714.     if (bridge.set_client_registration_callback_ptr != nullptr)

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

  716. #endif

  717.     return false;

  718. }

  719. 

  720. #if 0

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

  722. {

  723. #if JACKBRIDGE_DUMMY

  724. #elif JACKBRIDGE_DIRECT

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

  726. #else

  727.     if (bridge.set_client_rename_callback_ptr != nullptr)

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

  729. #endif

  730.     return false;

  731. }

  732. #endif

  733. 

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

  735. {

  736. #if JACKBRIDGE_DUMMY

  737. #elif JACKBRIDGE_DIRECT

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

  739. #else

  740.     if (bridge.set_port_registration_callback_ptr != nullptr)

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

  742. #endif

  743.     return false;

  744. }

  745. 

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

  747. {

  748. #if JACKBRIDGE_DUMMY

  749. #elif JACKBRIDGE_DIRECT

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

  751. #else

  752.     if (bridge.set_port_connect_callback_ptr != nullptr)

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

  754. #endif

  755.     return false;

  756. }

  757. 

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

  759. {

  760. #if JACKBRIDGE_DUMMY

  761. #elif JACKBRIDGE_DIRECT

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

  763. #else

  764.     if (bridge.set_port_rename_callback_ptr != nullptr)

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

  766. #endif

  767.     return false;

  768. }

  769. 

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

  771. {

  772. #if JACKBRIDGE_DUMMY

  773. #elif JACKBRIDGE_DIRECT

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

  775. #else

  776.     if (bridge.set_xrun_callback_ptr != nullptr)

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

  778. #endif

  779.     return false;

  780. }

  781. 

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

  783. {

  784. #if JACKBRIDGE_DUMMY

  785. #elif JACKBRIDGE_DIRECT

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

  787. #else

  788.     if (bridge.set_latency_callback_ptr != nullptr)

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

  790. #endif

  791.     return false;

  792. }

  793. 

  794. // -----------------------------------------------------------------------------

  795. 

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

  797. {

  798. #if JACKBRIDGE_DUMMY

  799. #elif JACKBRIDGE_DIRECT

  800.     return jack_set_freewheel(client, onoff);

  801. #else

  802.     if (bridge.set_freewheel_ptr != nullptr)

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

  804. #endif

  805.     return false;

  806. }

  807. 

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

  809. {

  810. #if JACKBRIDGE_DUMMY

  811. #elif JACKBRIDGE_DIRECT

  812.     return jack_set_buffer_size(client, nframes);

  813. #else

  814.     if (bridge.set_buffer_size_ptr != nullptr)

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

  816. #endif

  817.     return false;

  818. }

  819. 

  820. // -----------------------------------------------------------------------------

  821. 

  822. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  823. {

  824. #if JACKBRIDGE_DUMMY

  825. #elif JACKBRIDGE_DIRECT

  826.     return jack_get_sample_rate(client);

  827. #else

  828.     if (bridge.get_sample_rate_ptr != nullptr)

  829.         return bridge.get_sample_rate_ptr(client);

  830. #endif

  831.     return 0;

  832. }

  833. 

  834. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  835. {

  836. #if JACKBRIDGE_DUMMY

  837. #elif JACKBRIDGE_DIRECT

  838.     return jack_get_buffer_size(client);

  839. #else

  840.     if (bridge.get_buffer_size_ptr != nullptr)

  841.         return bridge.get_buffer_size_ptr(client);

  842. #endif

  843.     return 0;

  844. }

  845. 

  846. float jackbridge_cpu_load(jack_client_t* client)

  847. {

  848. #if JACKBRIDGE_DUMMY

  849. #elif JACKBRIDGE_DIRECT

  850.     return jack_cpu_load(client);

  851. #else

  852.     if (bridge.cpu_load_ptr != nullptr)

  853.         return bridge.cpu_load_ptr(client);

  854. #endif

  855.     return 0.0f;

  856. }

  857. 

  858. // -----------------------------------------------------------------------------

  859. 

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

  861. {

  862. #if JACKBRIDGE_DUMMY

  863. #elif JACKBRIDGE_DIRECT

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

  865. #else

  866.     if (bridge.port_register_ptr != nullptr)

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

  868. #endif

  869.     return nullptr;

  870. }

  871. 

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

  873. {

  874. #if JACKBRIDGE_DUMMY

  875. #elif JACKBRIDGE_DIRECT

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

  877. #else

  878.     if (bridge.port_unregister_ptr != nullptr)

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

  880. #endif

  881.     return false;

  882. }

  883. 

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

  885. {

  886. #if JACKBRIDGE_DUMMY

  887. #elif JACKBRIDGE_DIRECT

  888.     return jack_port_get_buffer(port, nframes);

  889. #else

  890.     if (bridge.port_get_buffer_ptr != nullptr)

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

  892. #endif

  893.     return nullptr;

  894. }

  895. 

  896. // -----------------------------------------------------------------------------

  897. 

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

  899. {

  900. #if JACKBRIDGE_DUMMY

  901. #elif JACKBRIDGE_DIRECT

  902.     return jack_port_name(port);

  903. #else

  904.     if (bridge.port_name_ptr != nullptr)

  905.         return bridge.port_name_ptr(port);

  906. #endif

  907.     return nullptr;

  908. }

  909. 

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

  911. {

  912. #if JACKBRIDGE_DUMMY

  913. #elif JACKBRIDGE_DIRECT

  914.     return jack_port_short_name(port);

  915. #else

  916.     if (bridge.port_short_name_ptr != nullptr)

  917.         return bridge.port_short_name_ptr(port);

  918. #endif

  919.     return nullptr;

  920. }

  921. 

  922. int jackbridge_port_flags(const jack_port_t* port)

  923. {

  924. #if JACKBRIDGE_DUMMY

  925. #elif JACKBRIDGE_DIRECT

  926.     return jack_port_flags(port);

  927. #else

  928.     if (bridge.port_flags_ptr != nullptr)

  929.         return bridge.port_flags_ptr(port);

  930. #endif

  931.     return 0x0;

  932. }

  933. 

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

  935. {

  936. #if JACKBRIDGE_DUMMY

  937. #elif JACKBRIDGE_DIRECT

  938.     return jack_port_type(port);

  939. #else

  940.     if (bridge.port_type_ptr != nullptr)

  941.         return bridge.port_type_ptr(port);

  942. #endif

  943.     return nullptr;

  944. }

  945. 

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

  947. {

  948. #if JACKBRIDGE_DUMMY

  949. #elif JACKBRIDGE_DIRECT

  950.     return jack_port_is_mine(client, port);

  951. #else

  952.     if (bridge.port_is_mine_ptr != nullptr)

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

  954. #endif

  955.     return false;

  956. }

  957. 

  958. bool jackbridge_port_connected(const jack_port_t* port)

  959. {

  960. #if JACKBRIDGE_DUMMY

  961. #elif JACKBRIDGE_DIRECT

  962.     return jack_port_connected(port);

  963. #else

  964.     if (bridge.port_connected_ptr != nullptr)

  965.         return bridge.port_connected_ptr(port);

  966. #endif

  967.     return false;

  968. }

  969. 

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

  971. {

  972. #if JACKBRIDGE_DUMMY

  973. #elif JACKBRIDGE_DIRECT

  974.     return jack_port_connected_to(port, port_name);

  975. #else

  976.     if (bridge.port_connected_to_ptr != nullptr)

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

  978. #endif

  979.     return false;

  980. }

  981. 

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

  983. {

  984. #if JACKBRIDGE_DUMMY

  985. #elif JACKBRIDGE_DIRECT

  986.     return jack_port_get_connections(port);

  987. #else

  988.     if (bridge.port_get_connections_ptr != nullptr)

  989.         return bridge.port_get_connections_ptr(port);

  990. #endif

  991.     return nullptr;

  992. }

  993. 

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

  995. {

  996. #if JACKBRIDGE_DUMMY

  997. #elif JACKBRIDGE_DIRECT

  998.     return jack_port_get_all_connections(client, port);

  999. #else

  1000.     if (bridge.port_get_all_connections_ptr != nullptr)

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

  1002. #endif

  1003.     return nullptr;

  1004. }

  1005. 

  1006. // -----------------------------------------------------------------------------

  1007. 

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

  1009. {

  1010. #if JACKBRIDGE_DUMMY

  1011. #elif JACKBRIDGE_DIRECT

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

  1013. #else

  1014.     if (bridge.port_set_name_ptr != nullptr)

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

  1016. #endif

  1017.     return false;

  1018. }

  1019. 

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

  1021. {

  1022. #if JACKBRIDGE_DUMMY

  1023. #elif JACKBRIDGE_DIRECT

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

  1025. #else

  1026.     if (bridge.port_set_alias_ptr != nullptr)

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

  1028. #endif

  1029.     return false;

  1030. }

  1031. 

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

  1033. {

  1034. #if JACKBRIDGE_DUMMY

  1035. #elif JACKBRIDGE_DIRECT

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

  1037. #else

  1038.     if (bridge.port_unset_alias_ptr != nullptr)

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

  1040. #endif

  1041.     return false;

  1042. }

  1043. 

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

  1045. {

  1046. #if JACKBRIDGE_DUMMY

  1047. #elif JACKBRIDGE_DIRECT

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

  1049. #else

  1050.     if (bridge.port_get_aliases_ptr != nullptr)

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

  1052. #endif

  1053.     return 0;

  1054. }

  1055. 

  1056. // -----------------------------------------------------------------------------

  1057. 

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

  1059. {

  1060. #if JACKBRIDGE_DUMMY

  1061. #elif JACKBRIDGE_DIRECT

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

  1063. #else

  1064.     if (bridge.port_request_monitor_ptr != nullptr)

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

  1066. #endif

  1067.     return false;

  1068. }

  1069. 

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

  1071. {

  1072. #if JACKBRIDGE_DUMMY

  1073. #elif JACKBRIDGE_DIRECT

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

  1075. #else

  1076.     if (bridge.port_request_monitor_by_name_ptr != nullptr)

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

  1078. #endif

  1079.     return false;

  1080. }

  1081. 

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

  1083. {

  1084. #if JACKBRIDGE_DUMMY

  1085. #elif JACKBRIDGE_DIRECT

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

  1087. #else

  1088.     if (bridge.port_ensure_monitor_ptr != nullptr)

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

  1090. #endif

  1091.     return false;

  1092. }

  1093. 

  1094. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1095. {

  1096. #if JACKBRIDGE_DUMMY

  1097. #elif JACKBRIDGE_DIRECT

  1098.     return jack_port_monitoring_input(port);

  1099. #else

  1100.     if (bridge.port_monitoring_input_ptr != nullptr)

  1101.         return bridge.port_monitoring_input_ptr(port);

  1102. #endif

  1103.     return false;

  1104. }

  1105. 

  1106. // -----------------------------------------------------------------------------

  1107. 

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

  1109. {

  1110. #if JACKBRIDGE_DUMMY

  1111. #elif JACKBRIDGE_DIRECT

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

  1113. #else

  1114.     if (bridge.connect_ptr != nullptr)

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

  1116. #endif

  1117.     return false;

  1118. }

  1119. 

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

  1121. {

  1122. #if JACKBRIDGE_DUMMY

  1123. #elif JACKBRIDGE_DIRECT

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

  1125. #else

  1126.     if (bridge.disconnect_ptr != nullptr)

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

  1128. #endif

  1129.     return false;

  1130. }

  1131. 

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

  1133. {

  1134. #if JACKBRIDGE_DUMMY

  1135. #elif JACKBRIDGE_DIRECT

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

  1137. #else

  1138.     if (bridge.port_disconnect_ptr != nullptr)

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

  1140. #endif

  1141.     return false;

  1142. }

  1143. 

  1144. // -----------------------------------------------------------------------------

  1145. 

  1146. int jackbridge_port_name_size()

  1147. {

  1148. #if JACKBRIDGE_DUMMY

  1149. #elif JACKBRIDGE_DIRECT

  1150.     return jack_port_name_size();

  1151. #else

  1152.     if (bridge.port_name_size_ptr != nullptr)

  1153.         return bridge.port_name_size_ptr();

  1154. #endif

  1155.     return 0;

  1156. }

  1157. 

  1158. int jackbridge_port_type_size()

  1159. {

  1160. #if JACKBRIDGE_DUMMY

  1161. #elif JACKBRIDGE_DIRECT

  1162.     return jack_port_type_size();

  1163. #else

  1164.     if (bridge.port_type_size_ptr != nullptr)

  1165.         return bridge.port_type_size_ptr();

  1166. #endif

  1167.     return 0;

  1168. }

  1169. 

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

  1171. {

  1172. #if JACKBRIDGE_DUMMY

  1173. #elif JACKBRIDGE_DIRECT

  1174.     return jack_port_type_get_buffer_size(client, port_type);

  1175. #else

  1176.     if (bridge.port_type_get_buffer_size_ptr != nullptr)

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

  1178. #endif

  1179.     return 0;

  1180. }

  1181. 

  1182. // -----------------------------------------------------------------------------

  1183. 

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

  1185. {

  1186. #if JACKBRIDGE_DUMMY

  1187. #elif JACKBRIDGE_DIRECT

  1188.     jack_port_get_latency_range(port, mode, range);

  1189. #else

  1190.     if (bridge.port_get_latency_range_ptr != nullptr)

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

  1192. #endif

  1193. }

  1194. 

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

  1196. {

  1197. #if JACKBRIDGE_DUMMY

  1198. #elif JACKBRIDGE_DIRECT

  1199.     jack_port_set_latency_range(port, mode, range);

  1200. #else

  1201.     if (bridge.port_set_latency_range_ptr != nullptr)

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

  1203. #endif

  1204. }

  1205. 

  1206. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1207. {

  1208. #if JACKBRIDGE_DUMMY

  1209. #elif JACKBRIDGE_DIRECT

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

  1211. #else

  1212.     if (bridge.recompute_total_latencies_ptr != nullptr)

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

  1214. #endif

  1215.     return false;

  1216. }

  1217. 

  1218. // -----------------------------------------------------------------------------

  1219. 

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

  1221. {

  1222. #if JACKBRIDGE_DUMMY

  1223. #elif JACKBRIDGE_DIRECT

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

  1225. #else

  1226.     if (bridge.get_ports_ptr != nullptr)

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

  1228. #endif

  1229.     return nullptr;

  1230. }

  1231. 

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

  1233. {

  1234. #if JACKBRIDGE_DUMMY

  1235. #elif JACKBRIDGE_DIRECT

  1236.     return jack_port_by_name(client, port_name);

  1237. #else

  1238.     if (bridge.port_by_name_ptr != nullptr)

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

  1240. #endif

  1241.     return nullptr;

  1242. }

  1243. 

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

  1245. {

  1246. #if JACKBRIDGE_DUMMY

  1247. #elif JACKBRIDGE_DIRECT

  1248.     return jack_port_by_id(client, port_id);

  1249. #else

  1250.     if (bridge.port_by_id_ptr != nullptr)

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

  1252. #endif

  1253.     return nullptr;

  1254. }

  1255. 

  1256. // -----------------------------------------------------------------------------

  1257. 

  1258. void jackbridge_free(void* ptr)

  1259. {

  1260. #if JACKBRIDGE_DUMMY

  1261. #elif JACKBRIDGE_DIRECT

  1262.     return jack_free(ptr);

  1263. #else

  1264.     if (bridge.free_ptr != nullptr)

  1265.         return bridge.free_ptr(ptr);

  1266. 

  1267.     // just in case

  1268.     std::free(ptr);

  1269. #endif

  1270. }

  1271. 

  1272. // -----------------------------------------------------------------------------

  1273. 

  1274. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1275. {

  1276. #if JACKBRIDGE_DUMMY

  1277. #elif JACKBRIDGE_DIRECT

  1278.     return jack_midi_get_event_count(port_buffer);

  1279. #else

  1280.     if (bridge.midi_get_event_count_ptr != nullptr)

  1281.         return bridge.midi_get_event_count_ptr(port_buffer);

  1282. #endif

  1283.     return 0;

  1284. }

  1285. 

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

  1287. {

  1288. #if JACKBRIDGE_DUMMY

  1289. #elif JACKBRIDGE_DIRECT

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

  1291. #else

  1292.     if (bridge.midi_event_get_ptr != nullptr)

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

  1294. #endif

  1295.     return false;

  1296. }

  1297. 

  1298. void jackbridge_midi_clear_buffer(void* port_buffer)

  1299. {

  1300. #if JACKBRIDGE_DUMMY

  1301. #elif JACKBRIDGE_DIRECT

  1302.     jack_midi_clear_buffer(port_buffer);

  1303. #else

  1304.     if (bridge.midi_clear_buffer_ptr != nullptr)

  1305.         bridge.midi_clear_buffer_ptr(port_buffer);

  1306. #endif

  1307. }

  1308. 

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

  1310. {

  1311. #if JACKBRIDGE_DUMMY

  1312. #elif JACKBRIDGE_DIRECT

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

  1314. #else

  1315.     if (bridge.midi_event_write_ptr != nullptr)

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

  1317. #endif

  1318.     return false;

  1319. }

  1320. 

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

  1322. {

  1323. #if JACKBRIDGE_DUMMY

  1324. #elif JACKBRIDGE_DIRECT

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

  1326. #else

  1327.     if (bridge.midi_event_reserve_ptr != nullptr)

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

  1329. #endif

  1330.     return nullptr;

  1331. }

  1332. 

  1333. // -----------------------------------------------------------------------------

  1334. 

  1335. bool jackbridge_release_timebase(jack_client_t* client)

  1336. {

  1337. #if JACKBRIDGE_DUMMY

  1338. #elif JACKBRIDGE_DIRECT

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

  1340. #else

  1341.     if (bridge.release_timebase_ptr != nullptr)

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

  1343. #endif

  1344.     return false;

  1345. }

  1346. 

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

  1348. {

  1349. #if JACKBRIDGE_DUMMY

  1350. #elif JACKBRIDGE_DIRECT

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

  1352. #else

  1353.     if (bridge.set_sync_callback_ptr != nullptr)

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

  1355. #endif

  1356.     return false;

  1357. }

  1358. 

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

  1360. {

  1361. #if JACKBRIDGE_DUMMY

  1362. #elif JACKBRIDGE_DIRECT

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

  1364. #else

  1365.     if (bridge.set_sync_timeout_ptr != nullptr)

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

  1367. #endif

  1368.     return false;

  1369. }

  1370. 

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

  1372. {

  1373. #if JACKBRIDGE_DUMMY

  1374. #elif JACKBRIDGE_DIRECT

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

  1376. #else

  1377.     if (bridge.set_timebase_callback_ptr != nullptr)

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

  1379. #endif

  1380.     return false;

  1381. }

  1382. 

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

  1384. {

  1385. #if JACKBRIDGE_DUMMY

  1386. #elif JACKBRIDGE_DIRECT

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

  1388. #else

  1389.     if (bridge.transport_locate_ptr != nullptr)

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

  1391. #endif

  1392.     return false;

  1393. }

  1394. 

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

  1396. {

  1397. #if JACKBRIDGE_DUMMY

  1398. #elif JACKBRIDGE_DIRECT

  1399.     return jack_transport_query(client, pos);

  1400. #else

  1401.     if (bridge.transport_query_ptr != nullptr)

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

  1403. #endif

  1404.     if (pos != nullptr)

  1405.     {

  1406.         // invalidate

  1407.         pos->unique_1 = 0;

  1408.         pos->unique_2 = 1;

  1409.     }

  1410.     return JackTransportStopped;

  1411. }

  1412. 

  1413. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1414. {

  1415. #if JACKBRIDGE_DUMMY

  1416. #elif JACKBRIDGE_DIRECT

  1417.     return jack_get_current_transport_frame(client);

  1418. #else

  1419.     if (bridge.get_current_transport_frame_ptr != nullptr)

  1420.         return bridge.get_current_transport_frame_ptr(client);

  1421. #endif

  1422.     return 0;

  1423. }

  1424. 

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

  1426. {

  1427. #if JACKBRIDGE_DUMMY

  1428. #elif JACKBRIDGE_DIRECT

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

  1430. #else

  1431.     if (bridge.transport_reposition_ptr != nullptr)

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

  1433. #endif

  1434.     return false;

  1435. }

  1436. 

  1437. void jackbridge_transport_start(jack_client_t* client)

  1438. {

  1439. #if JACKBRIDGE_DUMMY

  1440. #elif JACKBRIDGE_DIRECT

  1441.     jack_transport_start(client);

  1442. #else

  1443.     if (bridge.transport_start_ptr != nullptr)

  1444.         bridge.transport_start_ptr(client);

  1445. #endif

  1446. }

  1447. 

  1448. void jackbridge_transport_stop(jack_client_t* client)

  1449. {

  1450. #if JACKBRIDGE_DUMMY

  1451. #elif JACKBRIDGE_DIRECT

  1452.     jack_transport_stop(client);

  1453. #else

  1454.     if (bridge.transport_stop_ptr != nullptr)

  1455.         bridge.transport_stop_ptr(client);

  1456. #endif

  1457. }

  1458. 

  1459. // -----------------------------------------------------------------------------

  1460. 

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

  1462. {

  1463. #if JACKBRIDGE_DUMMY

  1464. #elif JACKBRIDGE_DIRECT

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

  1466. #else

  1467.     if (bridge.custom_publish_data_ptr != nullptr)

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

  1469. #endif

  1470.     return false;

  1471. }

  1472. 

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

  1474. {

  1475. #if JACKBRIDGE_DUMMY

  1476. #elif JACKBRIDGE_DIRECT

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

  1478. #else

  1479.     if (bridge.custom_get_data_ptr != nullptr)

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

  1481. #endif

  1482.     return false;

  1483. }

  1484. 

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

  1486. {

  1487. #if JACKBRIDGE_DUMMY

  1488. #elif JACKBRIDGE_DIRECT

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

  1490. #else

  1491.     if (bridge.custom_unpublish_data_ptr != nullptr)

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

  1493. #endif

  1494.     return false;

  1495. }

  1496. 

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

  1498. {

  1499. #if JACKBRIDGE_DUMMY

  1500. #elif JACKBRIDGE_DIRECT

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

  1502. #else

  1503.     if (bridge.custom_set_data_appearance_callback_ptr != nullptr)

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

  1505. #endif

  1506.     return false;

  1507. }

  1508. 

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

  1510. {

  1511. #if JACKBRIDGE_DUMMY

  1512. #elif JACKBRIDGE_DIRECT

  1513.     return jack_custom_get_keys(client, client_name);

  1514. #else

  1515.     if (bridge.custom_get_keys_ptr != nullptr)

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

  1517. #endif

  1518.     return nullptr;

  1519. }

  1520. 

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