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.
6556 Commits
16 Branches
3.6GB
Tree: 5b17dc7f07
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5b17dc7f07'
${ noResults }
Carla/source/jackbridge/JackBridge.hpp

433 lines
19KB
Raw Blame History 

  1. /*

  2.  * JackBridge

  3.  * Copyright (C) 2013-2019 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. #ifndef JACKBRIDGE_HPP_INCLUDED

  18. #define JACKBRIDGE_HPP_INCLUDED

  19. 

  20. #ifdef __WINE__

  21. # if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)

  22. #  define __WINE64__

  23. # endif

  24. # undef WIN32

  25. # undef WIN64

  26. # undef _WIN32

  27. # undef _WIN64

  28. # undef __WIN32__

  29. # undef __WIN64__

  30. #endif

  31. 

  32. #include "CarlaDefines.h"

  33. 

  34. #if (defined(__WINE__) || defined(CARLA_OS_WIN)) && defined(__cdecl)

  35. # define JACKBRIDGE_API __cdecl

  36. #else

  37. # define JACKBRIDGE_API

  38. #endif

  39. 

  40. #ifdef JACKBRIDGE_DIRECT

  41. # include <jack/jack.h>

  42. # include <jack/midiport.h>

  43. # include <jack/transport.h>

  44. # include <jack/session.h>

  45. # include <jack/metadata.h>

  46. # include <jack/uuid.h>

  47. #else

  48. 

  49. #include <cstddef>

  50. 

  51. #ifdef CARLA_PROPER_CPP11_SUPPORT

  52. # include <cstdint>

  53. #else

  54. # include <stdint.h>

  55. #endif

  56. 

  57. #ifndef POST_PACKED_STRUCTURE

  58. # if defined(__GNUC__)

  59.   /* POST_PACKED_STRUCTURE needs to be a macro which

  60.       expands into a compiler directive. The directive must

  61.       tell the compiler to arrange the preceding structure

  62.       declaration so that it is packed on byte-boundaries rather

  63.       than use the natural alignment of the processor and/or

  64.       compiler.

  65.   */

  66.   #define PRE_PACKED_STRUCTURE

  67.   #define POST_PACKED_STRUCTURE __attribute__((__packed__))

  68. # elif defined(_MSC_VER)

  69.   #define PRE_PACKED_STRUCTURE1 __pragma(pack(push,1))

  70.   #define PRE_PACKED_STRUCTURE    PRE_PACKED_STRUCTURE1

  71.   /* PRE_PACKED_STRUCTURE needs to be a macro which

  72.       expands into a compiler directive. The directive must

  73.       tell the compiler to arrange the following structure

  74.       declaration so that it is packed on byte-boundaries rather

  75.       than use the natural alignment of the processor and/or

  76.       compiler.

  77.   */

  78.   #define POST_PACKED_STRUCTURE ;__pragma(pack(pop))

  79.   /* and POST_PACKED_STRUCTURE needs to be a macro which

  80.       restores the packing to its previous setting */

  81. # else

  82.   #define PRE_PACKED_STRUCTURE

  83.   #define POST_PACKED_STRUCTURE

  84. # endif

  85. #endif

  86. 

  87. #if (defined(__arm__) || defined(__aarch64__) || defined(__mips__) || defined(__ppc__) || defined(__powerpc__)) && !defined(__APPLE__)

  88. # undef POST_PACKED_STRUCTURE

  89. # define POST_PACKED_STRUCTURE

  90. #endif

  91. 

  92. #define JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"

  93. #define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"

  94. 

  95. #define JACK_MAX_FRAMES (4294967295U)

  96. 

  97. #define JackOpenOptions (JackSessionID|JackServerName|JackNoStartServer|JackUseExactName)

  98. #define JackLoadOptions (JackLoadInit|JackLoadName|JackUseExactName)

  99. 

  100. #define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode|JackBBTFrameOffset|JackAudioVideoRatio|JackVideoFrameOffset)

  101. #define EXTENDED_TIME_INFO

  102. 

  103. #define JACK_UUID_SIZE 36

  104. #define JACK_UUID_STRING_SIZE (JACK_UUID_SIZE+1) /* includes trailing null */

  105. 

  106. #define JACK_TICK_DOUBLE

  107. 

  108. extern "C" {

  109. 

  110. enum JackOptions {

  111.     JackNullOption    = 0x00,

  112.     JackNoStartServer = 0x01,

  113.     JackUseExactName  = 0x02,

  114.     JackServerName    = 0x04,

  115.     JackLoadName      = 0x08,

  116.     JackLoadInit      = 0x10,

  117.     JackSessionID     = 0x20

  118. };

  119. 

  120. enum JackStatus {

  121.     JackFailure       = 0x0001,

  122.     JackInvalidOption = 0x0002,

  123.     JackNameNotUnique = 0x0004,

  124.     JackServerStarted = 0x0008,

  125.     JackServerFailed  = 0x0010,

  126.     JackServerError   = 0x0020,

  127.     JackNoSuchClient  = 0x0040,

  128.     JackLoadFailure   = 0x0080,

  129.     JackInitFailure   = 0x0100,

  130.     JackShmFailure    = 0x0200,

  131.     JackVersionError  = 0x0400,

  132.     JackBackendError  = 0x0800,

  133.     JackClientZombie  = 0x1000

  134. };

  135. 

  136. enum JackLatencyCallbackMode {

  137.     JackCaptureLatency,

  138.     JackPlaybackLatency

  139. };

  140. 

  141. enum JackPortFlags {

  142.     JackPortIsInput    = 0x01,

  143.     JackPortIsOutput   = 0x02,

  144.     JackPortIsPhysical = 0x04,

  145.     JackPortCanMonitor = 0x08,

  146.     JackPortIsTerminal = 0x10,

  147.     JackPortIsControlVoltage = 0x100

  148. };

  149. 

  150. enum JackTransportState {

  151.     JackTransportStopped  = 0,

  152.     JackTransportRolling  = 1,

  153.     JackTransportLooping  = 2,

  154.     JackTransportStarting = 3

  155. };

  156. 

  157. enum JackPositionBits {

  158.     JackPositionBBT      = 0x010,

  159.     JackPositionTimecode = 0x020,

  160.     JackBBTFrameOffset   = 0x040,

  161.     JackAudioVideoRatio  = 0x080,

  162.     JackVideoFrameOffset = 0x100,

  163.     JackTickDouble       = 0x200

  164. };

  165. 

  166. enum JackSessionEventType {

  167.     JackSessionSave         = 1,

  168.     JackSessionSaveAndQuit  = 2,

  169.     JackSessionSaveTemplate = 3

  170. };

  171. 

  172. enum JackSessionFlags {

  173.     JackSessionSaveError    = 0x1,

  174.     JackSessionNeedTerminal = 0x2

  175. };

  176. 

  177. enum JackPropertyChange {

  178.     PropertyCreated,

  179.     PropertyChanged,

  180.     PropertyDeleted

  181. };

  182. 

  183. typedef uint32_t jack_nframes_t;

  184. typedef uint32_t jack_port_id_t;

  185. typedef uint64_t jack_time_t;

  186. typedef uint64_t jack_uuid_t;

  187. typedef uint64_t jack_unique_t;

  188. typedef uchar jack_midi_data_t;

  189. typedef float jack_default_audio_sample_t;

  190. 

  191. typedef enum JackOptions jack_options_t;

  192. typedef enum JackStatus jack_status_t;

  193. typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;

  194. typedef enum JackTransportState jack_transport_state_t;

  195. typedef enum JackPositionBits jack_position_bits_t;

  196. typedef enum JackSessionEventType jack_session_event_type_t;

  197. typedef enum JackSessionFlags jack_session_flags_t;

  198. typedef enum JackPropertyChange jack_property_change_t;

  199. 

  200. struct _jack_midi_event {

  201.     jack_nframes_t    time;

  202.     size_t            size;

  203.     jack_midi_data_t* buffer;

  204. };

  205. 

  206. // NOTE: packed in JACK2 but not in JACK1

  207. PRE_PACKED_STRUCTURE

  208. struct _jack_latency_range {

  209.     jack_nframes_t min;

  210.     jack_nframes_t max;

  211. } POST_PACKED_STRUCTURE;

  212. 

  213. PRE_PACKED_STRUCTURE

  214. struct _jack_position {

  215.     jack_unique_t  unique_1;

  216.     jack_time_t    usecs;

  217.     jack_nframes_t frame_rate;

  218.     jack_nframes_t frame;

  219.     jack_position_bits_t valid;

  220.     int32_t bar;

  221.     int32_t beat;

  222.     int32_t tick;

  223.     double  bar_start_tick;

  224.     float   beats_per_bar;

  225.     float   beat_type;

  226.     double  ticks_per_beat;

  227.     double  beats_per_minute;

  228.     double  frame_time;

  229.     double  next_time;

  230.     jack_nframes_t bbt_offset;

  231.     float          audio_frames_per_video_frame;

  232.     jack_nframes_t video_offset;

  233.     double         tick_double;

  234.     int32_t        padding[5];

  235.     jack_unique_t  unique_2;

  236. } POST_PACKED_STRUCTURE;

  237. 

  238. struct _jack_session_event {

  239.     jack_session_event_type_t type;

  240.     const char* session_dir;

  241.     const char* client_uuid;

  242.     char*       command_line;

  243.     jack_session_flags_t flags;

  244.     uint32_t future;

  245. };

  246. 

  247. struct _jack_session_command_t {

  248.     const char* uuid;

  249.     const char* client_name;

  250.     const char* command;

  251.     jack_session_flags_t flags;

  252. };

  253. 

  254. typedef struct {

  255.     const char* key;

  256.     const char* data;

  257.     const char* type;

  258. } jack_property_t;

  259. 

  260. typedef struct {

  261.     jack_uuid_t      subject;

  262.     uint32_t         property_cnt;

  263.     jack_property_t* properties;

  264.     uint32_t         property_size;

  265. } jack_description_t;

  266. 

  267. typedef struct _jack_port jack_port_t;

  268. typedef struct _jack_client jack_client_t;

  269. typedef struct _jack_midi_event jack_midi_event_t;

  270. typedef struct _jack_latency_range jack_latency_range_t;

  271. typedef struct _jack_position jack_position_t;

  272. typedef struct _jack_session_event jack_session_event_t;

  273. typedef struct _jack_session_command_t jack_session_command_t;

  274. 

  275. typedef void (JACKBRIDGE_API *JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);

  276. typedef int  (JACKBRIDGE_API *JackProcessCallback)(jack_nframes_t nframes, void* arg);

  277. typedef void (JACKBRIDGE_API *JackThreadInitCallback)(void* arg);

  278. typedef int  (JACKBRIDGE_API *JackGraphOrderCallback)(void* arg);

  279. typedef int  (JACKBRIDGE_API *JackXRunCallback)(void* arg);

  280. typedef int  (JACKBRIDGE_API *JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);

  281. typedef int  (JACKBRIDGE_API *JackSampleRateCallback)(jack_nframes_t nframes, void* arg);

  282. typedef void (JACKBRIDGE_API *JackPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg);

  283. typedef void (JACKBRIDGE_API *JackClientRegistrationCallback)(const char* name, int register_, void* arg);

  284. typedef void (JACKBRIDGE_API *JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);

  285. typedef void (JACKBRIDGE_API *JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg);

  286. typedef void (JACKBRIDGE_API *JackFreewheelCallback)(int starting, void* arg);

  287. typedef void (JACKBRIDGE_API *JackShutdownCallback)(void* arg);

  288. typedef void (JACKBRIDGE_API *JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);

  289. typedef int  (JACKBRIDGE_API *JackSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg);

  290. typedef void (JACKBRIDGE_API *JackTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg);

  291. typedef void (JACKBRIDGE_API *JackSessionCallback)(jack_session_event_t* event, void* arg);

  292. typedef void (JACKBRIDGE_API *JackPropertyChangeCallback)(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg);

  293. 

  294. } // extern "C"

  295. 

  296. #endif // ! JACKBRIDGE_DIRECT

  297. 

  298. JACKBRIDGE_API bool jackbridge_is_ok() noexcept;

  299. JACKBRIDGE_API void jackbridge_init();

  300. 

  301. JACKBRIDGE_API void        jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);

  302. JACKBRIDGE_API const char* jackbridge_get_version_string();

  303. 

  304. JACKBRIDGE_API jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status);

  305. JACKBRIDGE_API bool           jackbridge_client_close(jack_client_t* client);

  306. 

  307. JACKBRIDGE_API int   jackbridge_client_name_size();

  308. JACKBRIDGE_API char* jackbridge_get_client_name(jack_client_t* client);

  309. 

  310. JACKBRIDGE_API char* jackbridge_client_get_uuid(jack_client_t* client);

  311. JACKBRIDGE_API char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name);

  312. JACKBRIDGE_API char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid);

  313. 

  314. JACKBRIDGE_API bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid);

  315. JACKBRIDGE_API void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE]);

  316. 

  317. JACKBRIDGE_API bool jackbridge_activate(jack_client_t* client);

  318. JACKBRIDGE_API bool jackbridge_deactivate(jack_client_t* client);

  319. JACKBRIDGE_API bool jackbridge_is_realtime(jack_client_t* client);

  320. 

  321. JACKBRIDGE_API bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);

  322. JACKBRIDGE_API void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);

  323. JACKBRIDGE_API void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);

  324. JACKBRIDGE_API bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);

  325. JACKBRIDGE_API bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);

  326. JACKBRIDGE_API bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);

  327. JACKBRIDGE_API bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);

  328. JACKBRIDGE_API bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);

  329. JACKBRIDGE_API bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);

  330. JACKBRIDGE_API bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);

  331. JACKBRIDGE_API bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);

  332. JACKBRIDGE_API bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);

  333. JACKBRIDGE_API bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);

  334. JACKBRIDGE_API bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);

  335. 

  336. JACKBRIDGE_API bool jackbridge_set_freewheel(jack_client_t* client, bool onoff);

  337. JACKBRIDGE_API bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);

  338. 

  339. JACKBRIDGE_API jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);

  340. JACKBRIDGE_API jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);

  341. JACKBRIDGE_API float          jackbridge_cpu_load(jack_client_t* client);

  342. 

  343. JACKBRIDGE_API 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);

  344. JACKBRIDGE_API bool         jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);

  345. JACKBRIDGE_API void*        jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

  346. 

  347. JACKBRIDGE_API const char*  jackbridge_port_name(const jack_port_t* port);

  348. JACKBRIDGE_API jack_uuid_t  jackbridge_port_uuid(const jack_port_t* port);

  349. JACKBRIDGE_API const char*  jackbridge_port_short_name(const jack_port_t* port);

  350. JACKBRIDGE_API int          jackbridge_port_flags(const jack_port_t* port);

  351. JACKBRIDGE_API const char*  jackbridge_port_type(const jack_port_t* port);

  352. JACKBRIDGE_API bool         jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);

  353. JACKBRIDGE_API int          jackbridge_port_connected(const jack_port_t* port);

  354. JACKBRIDGE_API bool         jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);

  355. JACKBRIDGE_API const char** jackbridge_port_get_connections(const jack_port_t* port);

  356. JACKBRIDGE_API const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);

  357. 

  358. JACKBRIDGE_API bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name);

  359. JACKBRIDGE_API bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);

  360. JACKBRIDGE_API bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);

  361. JACKBRIDGE_API int  jackbridge_port_get_aliases(const jack_port_t* port, char* const al[2]);

  362. 

  363. JACKBRIDGE_API bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff);

  364. JACKBRIDGE_API bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff);

  365. JACKBRIDGE_API bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff);

  366. JACKBRIDGE_API bool jackbridge_port_monitoring_input(jack_port_t* port);

  367. 

  368. JACKBRIDGE_API bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);

  369. JACKBRIDGE_API bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);

  370. JACKBRIDGE_API bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port);

  371. 

  372. JACKBRIDGE_API int      jackbridge_port_name_size();

  373. JACKBRIDGE_API int      jackbridge_port_type_size();

  374. JACKBRIDGE_API uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type);

  375. 

  376. JACKBRIDGE_API void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);

  377. JACKBRIDGE_API void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);

  378. JACKBRIDGE_API bool jackbridge_recompute_total_latencies(jack_client_t* client);

  379. 

  380. JACKBRIDGE_API const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags);

  381. JACKBRIDGE_API jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);

  382. JACKBRIDGE_API jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);

  383. 

  384. JACKBRIDGE_API void jackbridge_free(void* ptr);

  385. 

  386. JACKBRIDGE_API uint32_t jackbridge_midi_get_event_count(void* port_buffer);

  387. JACKBRIDGE_API bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);

  388. JACKBRIDGE_API void     jackbridge_midi_clear_buffer(void* port_buffer);

  389. JACKBRIDGE_API bool     jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size);

  390. JACKBRIDGE_API jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size);

  391. 

  392. JACKBRIDGE_API bool jackbridge_release_timebase(jack_client_t* client);

  393. JACKBRIDGE_API bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg);

  394. JACKBRIDGE_API bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout);

  395. JACKBRIDGE_API bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg);

  396. JACKBRIDGE_API bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);

  397. 

  398. JACKBRIDGE_API uint32_t       jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);

  399. JACKBRIDGE_API jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client);

  400. 

  401. JACKBRIDGE_API bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos);

  402. JACKBRIDGE_API void jackbridge_transport_start(jack_client_t* client);

  403. JACKBRIDGE_API void jackbridge_transport_stop(jack_client_t* client);

  404. 

  405. JACKBRIDGE_API bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type);

  406. JACKBRIDGE_API bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type);

  407. JACKBRIDGE_API void jackbridge_free_description(jack_description_t* desc, bool free_description_itself);

  408. JACKBRIDGE_API bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc);

  409. JACKBRIDGE_API bool jackbridge_get_all_properties(jack_description_t** descs);

  410. JACKBRIDGE_API bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);

  411. JACKBRIDGE_API int  jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject);

  412. JACKBRIDGE_API bool jackbridge_remove_all_properties(jack_client_t* client);

  413. JACKBRIDGE_API bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);

  414. 

  415. JACKBRIDGE_API bool jackbridge_sem_init(void* sem) noexcept;

  416. JACKBRIDGE_API void jackbridge_sem_destroy(void* sem) noexcept;

  417. JACKBRIDGE_API bool jackbridge_sem_connect(void* sem) noexcept;

  418. JACKBRIDGE_API void jackbridge_sem_post(void* sem, bool server) noexcept;

  419. #ifndef CARLA_OS_WASM

  420. JACKBRIDGE_API bool jackbridge_sem_timedwait(void* sem, uint msecs, bool server) noexcept;

  421. #endif

  422. 

  423. JACKBRIDGE_API bool  jackbridge_shm_is_valid(const void* shm) noexcept;

  424. JACKBRIDGE_API void  jackbridge_shm_init(void* shm) noexcept;

  425. JACKBRIDGE_API void  jackbridge_shm_attach(void* shm, const char* name) noexcept;

  426. JACKBRIDGE_API void  jackbridge_shm_close(void* shm) noexcept;

  427. JACKBRIDGE_API void* jackbridge_shm_map(void* shm, uint64_t size) noexcept;

  428. JACKBRIDGE_API void  jackbridge_shm_unmap(void* shm, void* ptr) noexcept;

  429. 

  430. JACKBRIDGE_API void jackbridge_parent_deathsig(bool kill) noexcept;

  431. 

  432. #endif // JACKBRIDGE_HPP_INCLUDED