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