JackBridge.hpp (19256B)
1 /* 2 * JackBridge for DPF 3 * Copyright (C) 2013-2021 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 "../DistrhoDefines.h" 33 34 #if (defined(__WINE__) || defined(DISTRHO_OS_WINDOWS)) && 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 DISTRHO_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 #define JACK_UUID_EMPTY_INITIALIZER 0 106 107 #define JACK_TICK_DOUBLE 108 109 extern "C" { 110 111 enum JackOptions { 112 JackNullOption = 0x00, 113 JackNoStartServer = 0x01, 114 JackUseExactName = 0x02, 115 JackServerName = 0x04, 116 JackLoadName = 0x08, 117 JackLoadInit = 0x10, 118 JackSessionID = 0x20 119 }; 120 121 enum JackStatus { 122 JackFailure = 0x0001, 123 JackInvalidOption = 0x0002, 124 JackNameNotUnique = 0x0004, 125 JackServerStarted = 0x0008, 126 JackServerFailed = 0x0010, 127 JackServerError = 0x0020, 128 JackNoSuchClient = 0x0040, 129 JackLoadFailure = 0x0080, 130 JackInitFailure = 0x0100, 131 JackShmFailure = 0x0200, 132 JackVersionError = 0x0400, 133 JackBackendError = 0x0800, 134 JackClientZombie = 0x1000, 135 JackBridgeNativeFailed = 0x10000 136 }; 137 138 enum JackLatencyCallbackMode { 139 JackCaptureLatency, 140 JackPlaybackLatency 141 }; 142 143 enum JackPortFlags { 144 JackPortIsInput = 0x01, 145 JackPortIsOutput = 0x02, 146 JackPortIsPhysical = 0x04, 147 JackPortCanMonitor = 0x08, 148 JackPortIsTerminal = 0x10, 149 JackPortIsControlVoltage = 0x100 150 }; 151 152 enum JackTransportState { 153 JackTransportStopped = 0, 154 JackTransportRolling = 1, 155 JackTransportLooping = 2, 156 JackTransportStarting = 3 157 }; 158 159 enum JackPositionBits { 160 JackPositionBBT = 0x010, 161 JackPositionTimecode = 0x020, 162 JackBBTFrameOffset = 0x040, 163 JackAudioVideoRatio = 0x080, 164 JackVideoFrameOffset = 0x100, 165 JackTickDouble = 0x200 166 }; 167 168 enum JackSessionEventType { 169 JackSessionSave = 1, 170 JackSessionSaveAndQuit = 2, 171 JackSessionSaveTemplate = 3 172 }; 173 174 enum JackSessionFlags { 175 JackSessionSaveError = 0x1, 176 JackSessionNeedTerminal = 0x2 177 }; 178 179 enum JackPropertyChange { 180 PropertyCreated, 181 PropertyChanged, 182 PropertyDeleted 183 }; 184 185 typedef uint32_t jack_nframes_t; 186 typedef uint32_t jack_port_id_t; 187 typedef uint64_t jack_time_t; 188 typedef uint64_t jack_uuid_t; 189 typedef uint64_t jack_unique_t; 190 typedef uchar jack_midi_data_t; 191 typedef float jack_default_audio_sample_t; 192 193 typedef enum JackOptions jack_options_t; 194 typedef enum JackStatus jack_status_t; 195 typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t; 196 typedef enum JackTransportState jack_transport_state_t; 197 typedef enum JackPositionBits jack_position_bits_t; 198 typedef enum JackSessionEventType jack_session_event_type_t; 199 typedef enum JackSessionFlags jack_session_flags_t; 200 typedef enum JackPropertyChange jack_property_change_t; 201 202 struct _jack_midi_event { 203 jack_nframes_t time; 204 size_t size; 205 jack_midi_data_t* buffer; 206 }; 207 208 // NOTE: packed in JACK2 but not in JACK1 209 PRE_PACKED_STRUCTURE 210 struct _jack_latency_range { 211 jack_nframes_t min; 212 jack_nframes_t max; 213 } POST_PACKED_STRUCTURE; 214 215 PRE_PACKED_STRUCTURE 216 struct _jack_position { 217 jack_unique_t unique_1; 218 jack_time_t usecs; 219 jack_nframes_t frame_rate; 220 jack_nframes_t frame; 221 jack_position_bits_t valid; 222 int32_t bar; 223 int32_t beat; 224 int32_t tick; 225 double bar_start_tick; 226 float beats_per_bar; 227 float beat_type; 228 double ticks_per_beat; 229 double beats_per_minute; 230 double frame_time; 231 double next_time; 232 jack_nframes_t bbt_offset; 233 float audio_frames_per_video_frame; 234 jack_nframes_t video_offset; 235 double tick_double; 236 int32_t padding[5]; 237 jack_unique_t unique_2; 238 } POST_PACKED_STRUCTURE; 239 240 struct _jack_session_event { 241 jack_session_event_type_t type; 242 const char* session_dir; 243 const char* client_uuid; 244 char* command_line; 245 jack_session_flags_t flags; 246 uint32_t future; 247 }; 248 249 struct _jack_session_command_t { 250 const char* uuid; 251 const char* client_name; 252 const char* command; 253 jack_session_flags_t flags; 254 }; 255 256 typedef struct { 257 const char* key; 258 const char* data; 259 const char* type; 260 } jack_property_t; 261 262 typedef struct { 263 jack_uuid_t subject; 264 uint32_t property_cnt; 265 jack_property_t* properties; 266 uint32_t property_size; 267 } jack_description_t; 268 269 typedef struct _jack_port jack_port_t; 270 typedef struct _jack_client jack_client_t; 271 typedef struct _jack_midi_event jack_midi_event_t; 272 typedef struct _jack_latency_range jack_latency_range_t; 273 typedef struct _jack_position jack_position_t; 274 typedef struct _jack_session_event jack_session_event_t; 275 typedef struct _jack_session_command_t jack_session_command_t; 276 277 typedef void (JACKBRIDGE_API *JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg); 278 typedef int (JACKBRIDGE_API *JackProcessCallback)(jack_nframes_t nframes, void* arg); 279 typedef void (JACKBRIDGE_API *JackThreadInitCallback)(void* arg); 280 typedef int (JACKBRIDGE_API *JackGraphOrderCallback)(void* arg); 281 typedef int (JACKBRIDGE_API *JackXRunCallback)(void* arg); 282 typedef int (JACKBRIDGE_API *JackBufferSizeCallback)(jack_nframes_t nframes, void* arg); 283 typedef int (JACKBRIDGE_API *JackSampleRateCallback)(jack_nframes_t nframes, void* arg); 284 typedef void (JACKBRIDGE_API *JackPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg); 285 typedef void (JACKBRIDGE_API *JackClientRegistrationCallback)(const char* name, int register_, void* arg); 286 typedef void (JACKBRIDGE_API *JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg); 287 typedef void (JACKBRIDGE_API *JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg); 288 typedef void (JACKBRIDGE_API *JackFreewheelCallback)(int starting, void* arg); 289 typedef void (JACKBRIDGE_API *JackShutdownCallback)(void* arg); 290 typedef void (JACKBRIDGE_API *JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg); 291 typedef int (JACKBRIDGE_API *JackSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg); 292 typedef void (JACKBRIDGE_API *JackTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg); 293 typedef void (JACKBRIDGE_API *JackSessionCallback)(jack_session_event_t* event, void* arg); 294 typedef void (JACKBRIDGE_API *JackPropertyChangeCallback)(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg); 295 typedef void *(JACKBRIDGE_API *JackThreadCallback)(void* arg); 296 297 } // extern "C" 298 299 #endif // ! JACKBRIDGE_DIRECT 300 301 JACKBRIDGE_API bool jackbridge_is_ok() noexcept; 302 JACKBRIDGE_API void jackbridge_init(); 303 304 JACKBRIDGE_API void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr); 305 JACKBRIDGE_API const char* jackbridge_get_version_string(); 306 307 JACKBRIDGE_API jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status); 308 JACKBRIDGE_API bool jackbridge_client_close(jack_client_t* client); 309 310 JACKBRIDGE_API int jackbridge_client_name_size(); 311 JACKBRIDGE_API const char* jackbridge_get_client_name(jack_client_t* client); 312 313 JACKBRIDGE_API char* jackbridge_client_get_uuid(jack_client_t* client); 314 JACKBRIDGE_API char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name); 315 JACKBRIDGE_API char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid); 316 317 JACKBRIDGE_API bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid); 318 JACKBRIDGE_API void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE]); 319 320 JACKBRIDGE_API bool jackbridge_activate(jack_client_t* client); 321 JACKBRIDGE_API bool jackbridge_deactivate(jack_client_t* client); 322 JACKBRIDGE_API bool jackbridge_is_realtime(jack_client_t* client); 323 324 JACKBRIDGE_API bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg); 325 JACKBRIDGE_API void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg); 326 JACKBRIDGE_API void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg); 327 JACKBRIDGE_API bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg); 328 JACKBRIDGE_API bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg); 329 JACKBRIDGE_API bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg); 330 JACKBRIDGE_API bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg); 331 JACKBRIDGE_API bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg); 332 JACKBRIDGE_API bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg); 333 JACKBRIDGE_API bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg); 334 JACKBRIDGE_API bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg); 335 JACKBRIDGE_API bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg); 336 JACKBRIDGE_API bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg); 337 JACKBRIDGE_API bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg); 338 339 JACKBRIDGE_API bool jackbridge_set_freewheel(jack_client_t* client, bool onoff); 340 JACKBRIDGE_API bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes); 341 342 JACKBRIDGE_API jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client); 343 JACKBRIDGE_API jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client); 344 JACKBRIDGE_API float jackbridge_cpu_load(jack_client_t* client); 345 346 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); 347 JACKBRIDGE_API bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port); 348 JACKBRIDGE_API void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes); 349 350 JACKBRIDGE_API const char* jackbridge_port_name(const jack_port_t* port); 351 JACKBRIDGE_API jack_uuid_t jackbridge_port_uuid(const jack_port_t* port); 352 JACKBRIDGE_API const char* jackbridge_port_short_name(const jack_port_t* port); 353 JACKBRIDGE_API int jackbridge_port_flags(const jack_port_t* port); 354 JACKBRIDGE_API const char* jackbridge_port_type(const jack_port_t* port); 355 JACKBRIDGE_API bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port); 356 JACKBRIDGE_API int jackbridge_port_connected(const jack_port_t* port); 357 JACKBRIDGE_API bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name); 358 JACKBRIDGE_API const char** jackbridge_port_get_connections(const jack_port_t* port); 359 JACKBRIDGE_API const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port); 360 361 JACKBRIDGE_API bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name); 362 JACKBRIDGE_API bool jackbridge_port_set_alias(jack_port_t* port, const char* alias); 363 JACKBRIDGE_API bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias); 364 JACKBRIDGE_API int jackbridge_port_get_aliases(const jack_port_t* port, char* const al[2]); 365 366 JACKBRIDGE_API bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff); 367 JACKBRIDGE_API bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff); 368 JACKBRIDGE_API bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff); 369 JACKBRIDGE_API bool jackbridge_port_monitoring_input(jack_port_t* port); 370 371 JACKBRIDGE_API bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port); 372 JACKBRIDGE_API bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port); 373 JACKBRIDGE_API bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port); 374 375 JACKBRIDGE_API int jackbridge_port_name_size(); 376 JACKBRIDGE_API int jackbridge_port_type_size(); 377 JACKBRIDGE_API uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type); 378 379 JACKBRIDGE_API void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range); 380 JACKBRIDGE_API void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range); 381 JACKBRIDGE_API bool jackbridge_recompute_total_latencies(jack_client_t* client); 382 383 JACKBRIDGE_API const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags); 384 JACKBRIDGE_API jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name); 385 JACKBRIDGE_API jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id); 386 387 JACKBRIDGE_API void jackbridge_free(void* ptr); 388 389 JACKBRIDGE_API uint32_t jackbridge_midi_get_event_count(void* port_buffer); 390 JACKBRIDGE_API bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index); 391 JACKBRIDGE_API void jackbridge_midi_clear_buffer(void* port_buffer); 392 JACKBRIDGE_API bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size); 393 JACKBRIDGE_API jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size); 394 395 JACKBRIDGE_API bool jackbridge_release_timebase(jack_client_t* client); 396 JACKBRIDGE_API bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg); 397 JACKBRIDGE_API bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout); 398 JACKBRIDGE_API bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg); 399 JACKBRIDGE_API bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame); 400 401 JACKBRIDGE_API uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos); 402 JACKBRIDGE_API jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client); 403 404 JACKBRIDGE_API bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos); 405 JACKBRIDGE_API void jackbridge_transport_start(jack_client_t* client); 406 JACKBRIDGE_API void jackbridge_transport_stop(jack_client_t* client); 407 408 JACKBRIDGE_API bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type); 409 JACKBRIDGE_API bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type); 410 JACKBRIDGE_API void jackbridge_free_description(jack_description_t* desc, bool free_description_itself); 411 JACKBRIDGE_API bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc); 412 JACKBRIDGE_API bool jackbridge_get_all_properties(jack_description_t** descs); 413 JACKBRIDGE_API bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key); 414 JACKBRIDGE_API int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject); 415 JACKBRIDGE_API bool jackbridge_remove_all_properties(jack_client_t* client); 416 JACKBRIDGE_API bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg); 417 418 JACKBRIDGE_API bool jackbridge_set_process_thread(jack_client_t* client, JackThreadCallback callback, void* arg); 419 JACKBRIDGE_API jack_nframes_t jackbridge_cycle_wait(jack_client_t* client); 420 JACKBRIDGE_API void jackbridge_cycle_signal(jack_client_t* client, int status); 421 422 #endif // JACKBRIDGE_HPP_INCLUDED