1 /*
2  * JackBridge (Part 3, Export)
3  * Copyright (C) 2013-2015 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 "JackBridgeExport.hpp"
18 
19 #include "CarlaLibUtils.hpp"
20 
21 // -----------------------------------------------------------------------------
22 
23 class JackBridgeExported
24 {
25 public:
JackBridgeExported()26     JackBridgeExported() noexcept
27         : lib(nullptr),
28           func(nullptr)
29     {
30 #ifdef CARLA_OS_WIN64
31         lib = lib_open("jackbridge-wine64.dll");
32 #else
33         lib = lib_open("jackbridge-wine32.dll");
34 #endif
35         CARLA_SAFE_ASSERT_RETURN(lib != nullptr,);
36 
37         func = lib_symbol<jackbridge_exported_function_type>(lib, "jackbridge_get_exported_functions");
38         CARLA_SAFE_ASSERT_RETURN(func != nullptr,);
39     }
40 
~JackBridgeExported()41     ~JackBridgeExported() noexcept
42     {
43         if (lib == nullptr)
44             return;
45 
46         lib_close(lib);
47         lib  = nullptr;
48         func = nullptr;
49     }
50 
getFunctions()51     static const JackBridgeExportedFunctions& getFunctions() noexcept
52     {
53         static JackBridgeExportedFunctions fallback;
54         carla_zeroStruct(fallback);
55         fallback.unique1 = 1;
56         fallback.unique2 = 2;
57         fallback.unique3 = 3;
58 
59         static const JackBridgeExported bridge;
60         CARLA_SAFE_ASSERT_RETURN(bridge.func != nullptr, fallback);
61 
62         const JackBridgeExportedFunctions* const funcs(bridge.func());
63         CARLA_SAFE_ASSERT_RETURN(funcs != nullptr, fallback);
64         CARLA_SAFE_ASSERT_RETURN(funcs->unique1 != 0, fallback);
65         CARLA_SAFE_ASSERT_RETURN(funcs->unique1 == funcs->unique2, fallback);
66         CARLA_SAFE_ASSERT_RETURN(funcs->unique2 == funcs->unique3, fallback);
67         CARLA_SAFE_ASSERT_RETURN(funcs->shm_map_ptr != nullptr, fallback);
68 
69         return *funcs;
70     }
71 
72 private:
73     lib_t lib;
74     jackbridge_exported_function_type func;
75 
76     CARLA_PREVENT_HEAP_ALLOCATION
77     CARLA_DECLARE_NON_COPY_CLASS(JackBridgeExported);
78 };
79 
80 // -----------------------------------------------------------------------------
81 
getBridgeInstance()82 static const JackBridgeExportedFunctions& getBridgeInstance() noexcept
83 {
84     static const JackBridgeExportedFunctions& funcs(JackBridgeExported::getFunctions());
85     return funcs;
86 }
87 
88 // -----------------------------------------------------------------------------
89 
jackbridge_is_ok()90 bool jackbridge_is_ok() noexcept
91 {
92     const JackBridgeExportedFunctions& instance(getBridgeInstance());
93     return (instance.unique1 != 0 && instance.unique1 == instance.unique2 && instance.init_ptr != nullptr);
94 }
95 
jackbridge_init()96 void jackbridge_init()
97 {
98     return getBridgeInstance().init_ptr();
99 }
100 
jackbridge_get_version(int * major_ptr,int * minor_ptr,int * micro_ptr,int * proto_ptr)101 void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr)
102 {
103     return getBridgeInstance().get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);
104 }
105 
jackbridge_get_version_string()106 const char* jackbridge_get_version_string()
107 {
108     return getBridgeInstance().get_version_string_ptr();
109 }
110 
jackbridge_client_open(const char * client_name,uint32_t options,jack_status_t * status)111 jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status)
112 {
113     return getBridgeInstance().client_open_ptr(client_name, options, status);
114 }
115 
jackbridge_client_close(jack_client_t * client)116 bool jackbridge_client_close(jack_client_t* client)
117 {
118     return getBridgeInstance().client_close_ptr(client);
119 }
120 
jackbridge_client_name_size()121 int jackbridge_client_name_size()
122 {
123     return getBridgeInstance().client_name_size_ptr();
124 }
125 
jackbridge_get_client_name(jack_client_t * client)126 char* jackbridge_get_client_name(jack_client_t* client)
127 {
128     return getBridgeInstance().get_client_name_ptr(client);
129 }
130 
jackbridge_client_get_uuid(jack_client_t * client)131 char* jackbridge_client_get_uuid(jack_client_t* client)
132 {
133     return getBridgeInstance().client_get_uuid_ptr(client);
134 }
135 
jackbridge_get_uuid_for_client_name(jack_client_t * client,const char * name)136 char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name)
137 {
138     return getBridgeInstance().get_uuid_for_client_name_ptr(client, name);
139 }
140 
jackbridge_get_client_name_by_uuid(jack_client_t * client,const char * uuid)141 char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid)
142 {
143     return getBridgeInstance().get_client_name_by_uuid_ptr(client, uuid);
144 }
145 
jackbridge_uuid_parse(const char * buf,jack_uuid_t * uuid)146 bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid)
147 {
148     return getBridgeInstance().uuid_parse_ptr(buf, uuid);
149 }
150 
jackbridge_activate(jack_client_t * client)151 bool jackbridge_activate(jack_client_t* client)
152 {
153     return getBridgeInstance().activate_ptr(client);
154 }
155 
jackbridge_deactivate(jack_client_t * client)156 bool jackbridge_deactivate(jack_client_t* client)
157 {
158     return getBridgeInstance().deactivate_ptr(client);
159 }
160 
jackbridge_is_realtime(jack_client_t * client)161 bool jackbridge_is_realtime(jack_client_t* client)
162 {
163     return getBridgeInstance().is_realtime_ptr(client);
164 }
165 
jackbridge_set_thread_init_callback(jack_client_t * client,JackThreadInitCallback thread_init_callback,void * arg)166 bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg)
167 {
168     return getBridgeInstance().set_thread_init_callback_ptr(client, thread_init_callback, arg);
169 }
170 
jackbridge_on_shutdown(jack_client_t * client,JackShutdownCallback shutdown_callback,void * arg)171 void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)
172 {
173     return getBridgeInstance().on_shutdown_ptr(client, shutdown_callback, arg);
174 }
175 
jackbridge_on_info_shutdown(jack_client_t * client,JackInfoShutdownCallback shutdown_callback,void * arg)176 void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg)
177 {
178     return getBridgeInstance().on_info_shutdown_ptr(client, shutdown_callback, arg);
179 }
180 
jackbridge_set_process_callback(jack_client_t * client,JackProcessCallback process_callback,void * arg)181 bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)
182 {
183     return getBridgeInstance().set_process_callback_ptr(client, process_callback, arg);
184 }
185 
jackbridge_set_freewheel_callback(jack_client_t * client,JackFreewheelCallback freewheel_callback,void * arg)186 bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)
187 {
188     return getBridgeInstance().set_freewheel_callback_ptr(client, freewheel_callback, arg);
189 }
190 
jackbridge_set_buffer_size_callback(jack_client_t * client,JackBufferSizeCallback bufsize_callback,void * arg)191 bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)
192 {
193     return getBridgeInstance().set_buffer_size_callback_ptr(client, bufsize_callback, arg);
194 }
195 
jackbridge_set_sample_rate_callback(jack_client_t * client,JackSampleRateCallback srate_callback,void * arg)196 bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)
197 {
198     return getBridgeInstance().set_sample_rate_callback_ptr(client, srate_callback, arg);
199 }
200 
jackbridge_set_client_registration_callback(jack_client_t * client,JackClientRegistrationCallback registration_callback,void * arg)201 bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)
202 {
203     return getBridgeInstance().set_client_registration_callback_ptr(client, registration_callback, arg);
204 }
205 
jackbridge_set_port_registration_callback(jack_client_t * client,JackPortRegistrationCallback registration_callback,void * arg)206 bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)
207 {
208     return getBridgeInstance().set_port_registration_callback_ptr(client, registration_callback, arg);
209 }
210 
jackbridge_set_port_rename_callback(jack_client_t * client,JackPortRenameCallback rename_callback,void * arg)211 bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)
212 {
213     return getBridgeInstance().set_port_rename_callback_ptr(client, rename_callback, arg);
214 }
215 
jackbridge_set_port_connect_callback(jack_client_t * client,JackPortConnectCallback connect_callback,void * arg)216 bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)
217 {
218     return getBridgeInstance().set_port_connect_callback_ptr(client, connect_callback, arg);
219 }
220 
jackbridge_set_xrun_callback(jack_client_t * client,JackXRunCallback xrun_callback,void * arg)221 bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg)
222 {
223     return getBridgeInstance().set_xrun_callback_ptr(client, xrun_callback, arg);
224 }
225 
jackbridge_set_latency_callback(jack_client_t * client,JackLatencyCallback latency_callback,void * arg)226 bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)
227 {
228     return getBridgeInstance().set_latency_callback_ptr(client, latency_callback, arg);
229 }
230 
jackbridge_set_freewheel(jack_client_t * client,bool onoff)231 bool jackbridge_set_freewheel(jack_client_t* client, bool onoff)
232 {
233     return getBridgeInstance().set_freewheel_ptr(client, onoff);
234 }
235 
jackbridge_set_buffer_size(jack_client_t * client,jack_nframes_t nframes)236 bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes)
237 {
238     return getBridgeInstance().set_buffer_size_ptr(client, nframes);
239 }
240 
jackbridge_get_sample_rate(jack_client_t * client)241 jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)
242 {
243     return getBridgeInstance().get_sample_rate_ptr(client);
244 }
245 
jackbridge_get_buffer_size(jack_client_t * client)246 jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)
247 {
248     return getBridgeInstance().get_buffer_size_ptr(client);
249 }
250 
jackbridge_cpu_load(jack_client_t * client)251 float jackbridge_cpu_load(jack_client_t* client)
252 {
253     return getBridgeInstance().cpu_load_ptr(client);
254 }
255 
jackbridge_port_register(jack_client_t * client,const char * port_name,const char * port_type,uint64_t flags,uint64_t buffer_size)256 jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, uint64_t flags, uint64_t buffer_size)
257 {
258     return getBridgeInstance().port_register_ptr(client, port_name, port_type, flags, buffer_size);
259 }
260 
jackbridge_port_unregister(jack_client_t * client,jack_port_t * port)261 bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)
262 {
263     return getBridgeInstance().port_unregister_ptr(client, port);
264 }
265 
jackbridge_port_get_buffer(jack_port_t * port,jack_nframes_t nframes)266 void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)
267 {
268     return getBridgeInstance().port_get_buffer_ptr(port, nframes);
269 }
270 
jackbridge_port_name(const jack_port_t * port)271 const char* jackbridge_port_name(const jack_port_t* port)
272 {
273     return getBridgeInstance().port_name_ptr(port);
274 }
275 
jackbridge_port_uuid(const jack_port_t * port)276 jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)
277 {
278     return getBridgeInstance().port_uuid_ptr(port);
279 }
280 
jackbridge_port_short_name(const jack_port_t * port)281 const char* jackbridge_port_short_name(const jack_port_t* port)
282 {
283     return getBridgeInstance().port_short_name_ptr(port);
284 }
285 
jackbridge_port_flags(const jack_port_t * port)286 int jackbridge_port_flags(const jack_port_t* port)
287 {
288     return getBridgeInstance().port_flags_ptr(port);
289 }
290 
jackbridge_port_type(const jack_port_t * port)291 const char* jackbridge_port_type(const jack_port_t* port)
292 {
293     return getBridgeInstance().port_type_ptr(port);
294 }
295 
jackbridge_port_is_mine(const jack_client_t * client,const jack_port_t * port)296 bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port)
297 {
298     return getBridgeInstance().port_is_mine_ptr(client, port);
299 }
300 
jackbridge_port_connected(const jack_port_t * port)301 int jackbridge_port_connected(const jack_port_t* port)
302 {
303     return getBridgeInstance().port_connected_ptr(port);
304 }
305 
jackbridge_port_connected_to(const jack_port_t * port,const char * port_name)306 bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name)
307 {
308     return getBridgeInstance().port_connected_to_ptr(port, port_name);
309 }
310 
jackbridge_port_get_connections(const jack_port_t * port)311 const char** jackbridge_port_get_connections(const jack_port_t* port)
312 {
313     return getBridgeInstance().port_get_connections_ptr(port);
314 }
315 
jackbridge_port_get_all_connections(const jack_client_t * client,const jack_port_t * port)316 const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port)
317 {
318     return getBridgeInstance().port_get_all_connections_ptr(client, port);
319 }
320 
jackbridge_port_rename(jack_client_t * client,jack_port_t * port,const char * port_name)321 bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name)
322 {
323     return getBridgeInstance().port_rename_ptr(client, port, port_name);
324 }
325 
jackbridge_port_set_alias(jack_port_t * port,const char * alias)326 bool jackbridge_port_set_alias(jack_port_t* port, const char* alias)
327 {
328     return getBridgeInstance().port_set_alias_ptr(port, alias);
329 }
330 
jackbridge_port_unset_alias(jack_port_t * port,const char * alias)331 bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias)
332 {
333     return getBridgeInstance().port_unset_alias_ptr(port, alias);
334 }
335 
jackbridge_port_get_aliases(const jack_port_t * port,char * const aliases[2])336 int jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2])
337 {
338     return getBridgeInstance().port_get_aliases_ptr(port, aliases);
339 }
340 
jackbridge_port_request_monitor(jack_port_t * port,bool onoff)341 bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff)
342 {
343     return getBridgeInstance().port_request_monitor_ptr(port, onoff);
344 }
345 
jackbridge_port_request_monitor_by_name(jack_client_t * client,const char * port_name,bool onoff)346 bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff)
347 {
348     return getBridgeInstance().port_request_monitor_by_name_ptr(client, port_name, onoff);
349 }
350 
jackbridge_port_ensure_monitor(jack_port_t * port,bool onoff)351 bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff)
352 {
353     return getBridgeInstance().port_ensure_monitor_ptr(port, onoff);
354 }
355 
jackbridge_port_monitoring_input(jack_port_t * port)356 bool jackbridge_port_monitoring_input(jack_port_t* port)
357 {
358     return getBridgeInstance().port_monitoring_input_ptr(port);
359 }
360 
jackbridge_connect(jack_client_t * client,const char * source_port,const char * destination_port)361 bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)
362 {
363     return getBridgeInstance().connect_ptr(client, source_port, destination_port);
364 }
365 
jackbridge_disconnect(jack_client_t * client,const char * source_port,const char * destination_port)366 bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)
367 {
368     return getBridgeInstance().disconnect_ptr(client, source_port, destination_port);
369 }
370 
jackbridge_port_disconnect(jack_client_t * client,jack_port_t * port)371 bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port)
372 {
373     return getBridgeInstance().port_disconnect_ptr(client, port);
374 }
375 
jackbridge_port_name_size()376 int jackbridge_port_name_size()
377 {
378     return getBridgeInstance().port_name_size_ptr();
379 }
380 
jackbridge_port_type_size()381 int jackbridge_port_type_size()
382 {
383     return getBridgeInstance().port_type_size_ptr();
384 }
385 
jackbridge_port_type_get_buffer_size(jack_client_t * client,const char * port_type)386 uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type)
387 {
388     return getBridgeInstance().port_type_get_buffer_size_ptr(client, port_type);
389 }
390 
jackbridge_port_get_latency_range(jack_port_t * port,uint32_t mode,jack_latency_range_t * range)391 void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)
392 {
393     return getBridgeInstance().port_get_latency_range_ptr(port, mode, range);
394 }
395 
jackbridge_port_set_latency_range(jack_port_t * port,uint32_t mode,jack_latency_range_t * range)396 void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)
397 {
398     return getBridgeInstance().port_set_latency_range_ptr(port, mode, range);
399 }
400 
jackbridge_recompute_total_latencies(jack_client_t * client)401 bool jackbridge_recompute_total_latencies(jack_client_t* client)
402 {
403     return getBridgeInstance().recompute_total_latencies_ptr(client);
404 }
405 
jackbridge_get_ports(jack_client_t * client,const char * port_name_pattern,const char * type_name_pattern,uint64_t flags)406 const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags)
407 {
408     return getBridgeInstance().get_ports_ptr(client, port_name_pattern, type_name_pattern, flags);
409 }
410 
jackbridge_port_by_name(jack_client_t * client,const char * port_name)411 jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)
412 {
413     return getBridgeInstance().port_by_name_ptr(client, port_name);
414 }
415 
jackbridge_port_by_id(jack_client_t * client,jack_port_id_t port_id)416 jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)
417 {
418     return getBridgeInstance().port_by_id_ptr(client, port_id);
419 }
420 
jackbridge_free(void * ptr)421 void jackbridge_free(void* ptr)
422 {
423     return getBridgeInstance().free_ptr(ptr);
424 }
425 
jackbridge_midi_get_event_count(void * port_buffer)426 uint32_t jackbridge_midi_get_event_count(void* port_buffer)
427 {
428     return getBridgeInstance().midi_get_event_count_ptr(port_buffer);
429 }
430 
jackbridge_midi_event_get(jack_midi_event_t * event,void * port_buffer,uint32_t event_index)431 bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)
432 {
433     return getBridgeInstance().midi_event_get_ptr(event, port_buffer, event_index);
434 }
435 
jackbridge_midi_clear_buffer(void * port_buffer)436 void jackbridge_midi_clear_buffer(void* port_buffer)
437 {
438     return getBridgeInstance().midi_clear_buffer_ptr(port_buffer);
439 }
440 
jackbridge_midi_event_write(void * port_buffer,jack_nframes_t time,const jack_midi_data_t * data,uint32_t data_size)441 bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size)
442 {
443     return getBridgeInstance().midi_event_write_ptr(port_buffer, time, data, data_size);
444 }
445 
jackbridge_midi_event_reserve(void * port_buffer,jack_nframes_t time,uint32_t data_size)446 jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size)
447 {
448     return getBridgeInstance().midi_event_reserve_ptr(port_buffer, time, data_size);
449 }
450 
jackbridge_release_timebase(jack_client_t * client)451 bool jackbridge_release_timebase(jack_client_t* client)
452 {
453     return getBridgeInstance().release_timebase_ptr(client);
454 }
455 
jackbridge_set_sync_callback(jack_client_t * client,JackSyncCallback sync_callback,void * arg)456 bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg)
457 {
458     return getBridgeInstance().set_sync_callback_ptr(client, sync_callback, arg);
459 }
460 
jackbridge_set_sync_timeout(jack_client_t * client,jack_time_t timeout)461 bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout)
462 {
463     return getBridgeInstance().set_sync_timeout_ptr(client, timeout);
464 }
465 
jackbridge_set_timebase_callback(jack_client_t * client,bool conditional,JackTimebaseCallback timebase_callback,void * arg)466 bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg)
467 {
468     return getBridgeInstance().set_timebase_callback_ptr(client, conditional, timebase_callback, arg);
469 }
470 
jackbridge_transport_locate(jack_client_t * client,jack_nframes_t frame)471 bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)
472 {
473     return getBridgeInstance().transport_locate_ptr(client, frame);
474 }
475 
jackbridge_transport_query(const jack_client_t * client,jack_position_t * pos)476 uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)
477 {
478     return getBridgeInstance().transport_query_ptr(client, pos);
479 }
480 
jackbridge_get_current_transport_frame(const jack_client_t * client)481 jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)
482 {
483     return getBridgeInstance().get_current_transport_frame_ptr(client);
484 }
485 
jackbridge_transport_reposition(jack_client_t * client,const jack_position_t * pos)486 bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos)
487 {
488     return getBridgeInstance().transport_reposition_ptr(client, pos);
489 }
490 
jackbridge_transport_start(jack_client_t * client)491 void jackbridge_transport_start(jack_client_t* client)
492 {
493     return getBridgeInstance().transport_start_ptr(client);
494 }
495 
jackbridge_transport_stop(jack_client_t * client)496 void jackbridge_transport_stop(jack_client_t* client)
497 {
498     return getBridgeInstance().transport_stop_ptr(client);
499 }
500 
jackbridge_set_property(jack_client_t * client,jack_uuid_t subject,const char * key,const char * value,const char * type)501 bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type)
502 {
503     return getBridgeInstance().set_property_ptr(client, subject, key, value, type);
504 }
505 
jackbridge_get_property(jack_uuid_t subject,const char * key,char ** value,char ** type)506 bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type)
507 {
508     return getBridgeInstance().get_property_ptr(subject, key, value, type);
509 }
510 
jackbridge_free_description(jack_description_t * desc,bool free_description_itself)511 void jackbridge_free_description(jack_description_t* desc, bool free_description_itself)
512 {
513     return getBridgeInstance().free_description_ptr(desc, free_description_itself);
514 }
515 
jackbridge_get_properties(jack_uuid_t subject,jack_description_t * desc)516 bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc)
517 {
518     return getBridgeInstance().get_properties_ptr(subject, desc);
519 }
520 
jackbridge_get_all_properties(jack_description_t ** descs)521 bool jackbridge_get_all_properties(jack_description_t** descs)
522 {
523     return getBridgeInstance().get_all_properties_ptr(descs);
524 }
525 
jackbridge_remove_property(jack_client_t * client,jack_uuid_t subject,const char * key)526 bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key)
527 {
528     return getBridgeInstance().remove_property_ptr(client, subject, key);
529 }
530 
jackbridge_remove_properties(jack_client_t * client,jack_uuid_t subject)531 int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject)
532 {
533     return getBridgeInstance().remove_properties_ptr(client, subject);
534 }
535 
jackbridge_remove_all_properties(jack_client_t * client)536 bool jackbridge_remove_all_properties(jack_client_t* client)
537 {
538     return getBridgeInstance().remove_all_properties_ptr(client);
539 }
540 
jackbridge_set_property_change_callback(jack_client_t * client,JackPropertyChangeCallback callback,void * arg)541 bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg)
542 {
543     return getBridgeInstance().set_property_change_callback_ptr(client, callback, arg);
544 }
545 
jackbridge_sem_init(void * sem)546 bool jackbridge_sem_init(void* sem) noexcept
547 {
548     return getBridgeInstance().sem_init_ptr(sem);
549 }
550 
jackbridge_sem_destroy(void * sem)551 void jackbridge_sem_destroy(void* sem) noexcept
552 {
553     getBridgeInstance().sem_destroy_ptr(sem);
554 }
555 
jackbridge_sem_connect(void * sem)556 bool jackbridge_sem_connect(void* sem) noexcept
557 {
558     return getBridgeInstance().sem_connect_ptr(sem);
559 }
560 
jackbridge_sem_post(void * sem,bool server)561 void jackbridge_sem_post(void* sem, bool server) noexcept
562 {
563     getBridgeInstance().sem_post_ptr(sem, server);
564 }
565 
jackbridge_sem_timedwait(void * sem,uint msecs,bool server)566 bool jackbridge_sem_timedwait(void* sem, uint msecs, bool server) noexcept
567 {
568     return getBridgeInstance().sem_timedwait_ptr(sem, msecs, server);
569 }
570 
jackbridge_shm_is_valid(const void * shm)571 bool jackbridge_shm_is_valid(const void* shm) noexcept
572 {
573     return getBridgeInstance().shm_is_valid_ptr(shm);
574 }
575 
jackbridge_shm_init(void * shm)576 void jackbridge_shm_init(void* shm) noexcept
577 {
578     return getBridgeInstance().shm_init_ptr(shm);
579 }
580 
jackbridge_shm_attach(void * shm,const char * name)581 void jackbridge_shm_attach(void* shm, const char* name) noexcept
582 {
583     return getBridgeInstance().shm_attach_ptr(shm, name);
584 }
585 
jackbridge_shm_close(void * shm)586 void jackbridge_shm_close(void* shm) noexcept
587 {
588     return getBridgeInstance().shm_close_ptr(shm);
589 }
590 
jackbridge_shm_map(void * shm,uint64_t size)591 void* jackbridge_shm_map(void* shm, uint64_t size) noexcept
592 {
593     return getBridgeInstance().shm_map_ptr(shm, size);
594 }
595 
jackbridge_shm_unmap(void * shm,void * ptr)596 void jackbridge_shm_unmap(void* shm, void* ptr) noexcept
597 {
598     return getBridgeInstance().shm_unmap_ptr(shm, ptr);
599 }
600 
jackbridge_parent_deathsig(bool kill)601 void jackbridge_parent_deathsig(bool kill) noexcept
602 {
603     return getBridgeInstance().parent_deathsig_ptr(kill);
604 }
605 
606 // -----------------------------------------------------------------------------
607