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

405 lines
17KB
Raw Blame History 

  1. /*

  2.  * JackBridge

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

  33. # define __cdecl

  34. #endif

  35. 

  36. #include "CarlaDefines.h"

  37. 

  38. #ifdef JACKBRIDGE_DIRECT

  39. # include <jack/jack.h>

  40. # include <jack/midiport.h>

  41. # include <jack/transport.h>

  42. # include <jack/metadata.h>

  43. #else

  44. 

  45. #include <cstddef>

  46. 

  47. #ifdef CARLA_PROPER_CPP11_SUPPORT

  48. # include <cstdint>

  49. #else

  50. # include <stdint.h>

  51. #endif

  52. 

  53. #ifndef POST_PACKED_STRUCTURE

  54. # if defined(__GNUC__)

  55.   /* POST_PACKED_STRUCTURE needs to be a macro which

  56.       expands into a compiler directive. The directive must

  57.       tell the compiler to arrange the preceding structure

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

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

  60.       compiler.

  61.   */

  62.   #define PRE_PACKED_STRUCTURE

  63.   #define POST_PACKED_STRUCTURE __attribute__((__packed__))

  64. # elif defined(_MSC_VER)

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

  66.   #define PRE_PACKED_STRUCTURE    PRE_PACKED_STRUCTURE1

  67.   /* PRE_PACKED_STRUCTURE needs to be a macro which

  68.       expands into a compiler directive. The directive must

  69.       tell the compiler to arrange the following structure

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

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

  72.       compiler.

  73.   */

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

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

  76.       restores the packing to its previous setting */

  77. # else

  78.   #define PRE_PACKED_STRUCTURE

  79.   #define POST_PACKED_STRUCTURE

  80. # endif

  81. #endif

  82. 

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

  84. #define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"

  85. 

  86. #define JACK_MAX_FRAMES (4294967295U)

  87. 

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

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

  90. 

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

  92. #define EXTENDED_TIME_INFO

  93. 

  94. extern "C" {

  95. 

  96. enum JackOptions {

  97.     JackNullOption    = 0x00,

  98.     JackNoStartServer = 0x01,

  99.     JackUseExactName  = 0x02,

  100.     JackServerName    = 0x04,

  101.     JackLoadName      = 0x08,

  102.     JackLoadInit      = 0x10,

  103.     JackSessionID     = 0x20

  104. };

  105. 

  106. enum JackStatus {

  107.     JackFailure       = 0x0001,

  108.     JackInvalidOption = 0x0002,

  109.     JackNameNotUnique = 0x0004,

  110.     JackServerStarted = 0x0008,

  111.     JackServerFailed  = 0x0010,

  112.     JackServerError   = 0x0020,

  113.     JackNoSuchClient  = 0x0040,

  114.     JackLoadFailure   = 0x0080,

  115.     JackInitFailure   = 0x0100,

  116.     JackShmFailure    = 0x0200,

  117.     JackVersionError  = 0x0400,

  118.     JackBackendError  = 0x0800,

  119.     JackClientZombie  = 0x1000

  120. };

  121. 

  122. enum JackLatencyCallbackMode {

  123.     JackCaptureLatency,

  124.     JackPlaybackLatency

  125. };

  126. 

  127. enum JackPortFlags {

  128.     JackPortIsInput    = 0x01,

  129.     JackPortIsOutput   = 0x02,

  130.     JackPortIsPhysical = 0x04,

  131.     JackPortCanMonitor = 0x08,

  132.     JackPortIsTerminal = 0x10

  133. };

  134. 

  135. enum JackTransportState {

  136.     JackTransportStopped  = 0,

  137.     JackTransportRolling  = 1,

  138.     JackTransportLooping  = 2,

  139.     JackTransportStarting = 3

  140. };

  141. 

  142. enum JackPositionBits {

  143.     JackPositionBBT      = 0x010,

  144.     JackPositionTimecode = 0x020,

  145.     JackBBTFrameOffset   = 0x040,

  146.     JackAudioVideoRatio  = 0x080,

  147.     JackVideoFrameOffset = 0x100

  148. };

  149. 

  150. enum JackSessionEventType {

  151.     JackSessionSave         = 1,

  152.     JackSessionSaveAndQuit  = 2,

  153.     JackSessionSaveTemplate = 3

  154. };

  155. 

  156. enum JackSessionFlags {

  157.     JackSessionSaveError    = 0x1,

  158.     JackSessionNeedTerminal = 0x2

  159. };

  160. 

  161. enum JackPropertyChange {

  162.     PropertyCreated,

  163.     PropertyChanged,

  164.     PropertyDeleted

  165. };

  166. 

  167. typedef uint32_t jack_nframes_t;

  168. typedef uint32_t jack_port_id_t;

  169. typedef uint64_t jack_time_t;

  170. typedef uint64_t jack_uuid_t;

  171. typedef uint64_t jack_unique_t;

  172. typedef uchar jack_midi_data_t;

  173. typedef float jack_default_audio_sample_t;

  174. 

  175. typedef enum JackOptions jack_options_t;

  176. typedef enum JackStatus jack_status_t;

  177. typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;

  178. typedef enum JackTransportState jack_transport_state_t;

  179. typedef enum JackPositionBits jack_position_bits_t;

  180. typedef enum JackSessionEventType jack_session_event_type_t;

  181. typedef enum JackSessionFlags jack_session_flags_t;

  182. typedef enum JackPropertyChange jack_property_change_t;

  183. 

  184. struct _jack_midi_event {

  185.     jack_nframes_t    time;

  186.     size_t            size;

  187.     jack_midi_data_t* buffer;

  188. };

  189. 

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

  191. PRE_PACKED_STRUCTURE

  192. struct _jack_latency_range {

  193.     jack_nframes_t min;

  194.     jack_nframes_t max;

  195. } POST_PACKED_STRUCTURE;

  196. 

  197. PRE_PACKED_STRUCTURE

  198. struct _jack_position {

  199.     jack_unique_t  unique_1;

  200.     jack_time_t    usecs;

  201.     jack_nframes_t frame_rate;

  202.     jack_nframes_t frame;

  203.     jack_position_bits_t valid;

  204.     int32_t bar;

  205.     int32_t beat;

  206.     int32_t tick;

  207.     double  bar_start_tick;

  208.     float   beats_per_bar;

  209.     float   beat_type;

  210.     double  ticks_per_beat;

  211.     double  beats_per_minute;

  212.     double  frame_time;

  213.     double  next_time;

  214.     jack_nframes_t bbt_offset;

  215.     float          audio_frames_per_video_frame;

  216.     jack_nframes_t video_offset;

  217.     int32_t        padding[7];

  218.     jack_unique_t  unique_2;

  219. } POST_PACKED_STRUCTURE;

  220. 

  221. struct _jack_session_event {

  222.     jack_session_event_type_t type;

  223.     const char* session_dir;

  224.     const char* client_uuid;

  225.     char*       command_line;

  226.     jack_session_flags_t flags;

  227.     uint32_t future;

  228. };

  229. 

  230. struct _jack_session_command_t {

  231.     const char* uuid;

  232.     const char* client_name;

  233.     const char* command;

  234.     jack_session_flags_t flags;

  235. };

  236. 

  237. typedef struct {

  238.     const char* key;

  239.     const char* data;

  240.     const char* type;

  241. } jack_property_t;

  242. 

  243. typedef struct {

  244.     jack_uuid_t      subject;

  245.     uint32_t         property_cnt;

  246.     jack_property_t* properties;

  247.     uint32_t         property_size;

  248. } jack_description_t;

  249. 

  250. typedef struct _jack_port jack_port_t;

  251. typedef struct _jack_client jack_client_t;

  252. typedef struct _jack_midi_event jack_midi_event_t;

  253. typedef struct _jack_latency_range jack_latency_range_t;

  254. typedef struct _jack_position jack_position_t;

  255. typedef struct _jack_session_event jack_session_event_t;

  256. typedef struct _jack_session_command_t jack_session_command_t;

  257. 

  258. typedef void (__cdecl *JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);

  259. typedef int  (__cdecl *JackProcessCallback)(jack_nframes_t nframes, void* arg);

  260. typedef void (__cdecl *JackThreadInitCallback)(void* arg);

  261. typedef int  (__cdecl *JackGraphOrderCallback)(void* arg);

  262. typedef int  (__cdecl *JackXRunCallback)(void* arg);

  263. typedef int  (__cdecl *JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);

  264. typedef int  (__cdecl *JackSampleRateCallback)(jack_nframes_t nframes, void* arg);

  265. typedef void (__cdecl *JackPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg);

  266. typedef void (__cdecl *JackClientRegistrationCallback)(const char* name, int register_, void* arg);

  267. typedef void (__cdecl *JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);

  268. typedef int  (__cdecl *JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg); // NOTE: returns void in JACK1, int in JACK2

  269. typedef void (__cdecl *JackFreewheelCallback)(int starting, void* arg);

  270. typedef void (__cdecl *JackShutdownCallback)(void* arg);

  271. typedef void (__cdecl *JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);

  272. typedef int  (__cdecl *JackSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg);

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

  274. typedef void (__cdecl *JackSessionCallback)(jack_session_event_t* event, void* arg);

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

  276. 

  277. } // extern "C"

  278. 

  279. #endif // ! JACKBRIDGE_DIRECT

  280. 

  281. __cdecl bool jackbridge_is_ok() noexcept;

  282. 

  283. __cdecl void        jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);

  284. __cdecl const char* jackbridge_get_version_string();

  285. 

  286. __cdecl jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status);

  287. __cdecl bool           jackbridge_client_close(jack_client_t* client);

  288. 

  289. __cdecl int   jackbridge_client_name_size();

  290. __cdecl char* jackbridge_get_client_name(jack_client_t* client);

  291. 

  292. __cdecl char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name);

  293. __cdecl char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid);

  294. 

  295. __cdecl bool jackbridge_activate(jack_client_t* client);

  296. __cdecl bool jackbridge_deactivate(jack_client_t* client);

  297. __cdecl bool jackbridge_is_realtime(jack_client_t* client);

  298. 

  299. __cdecl bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);

  300. __cdecl void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);

  301. __cdecl void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);

  302. __cdecl bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);

  303. __cdecl bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);

  304. __cdecl bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);

  305. __cdecl bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);

  306. __cdecl bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);

  307. __cdecl bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);

  308. __cdecl bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);

  309. __cdecl bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);

  310. __cdecl bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);

  311. __cdecl bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);

  312. __cdecl bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);

  313. 

  314. __cdecl bool jackbridge_set_freewheel(jack_client_t* client, bool onoff);

  315. __cdecl bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);

  316. 

  317. __cdecl jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);

  318. __cdecl jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);

  319. __cdecl float          jackbridge_cpu_load(jack_client_t* client);

  320. 

  321. __cdecl jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, ulong flags, ulong buffer_size);

  322. __cdecl bool         jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);

  323. __cdecl void*        jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

  324. 

  325. __cdecl const char*  jackbridge_port_name(const jack_port_t* port);

  326. __cdecl jack_uuid_t  jackbridge_port_uuid(const jack_port_t* port);

  327. __cdecl const char*  jackbridge_port_short_name(const jack_port_t* port);

  328. __cdecl int          jackbridge_port_flags(const jack_port_t* port);

  329. __cdecl const char*  jackbridge_port_type(const jack_port_t* port);

  330. __cdecl bool         jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);

  331. __cdecl int          jackbridge_port_connected(const jack_port_t* port);

  332. __cdecl bool         jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);

  333. __cdecl const char** jackbridge_port_get_connections(const jack_port_t* port);

  334. __cdecl const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);

  335. 

  336. __cdecl bool jackbridge_port_set_name(jack_port_t* port, const char* port_name);

  337. __cdecl bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);

  338. __cdecl bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);

  339. __cdecl int  jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2]);

  340. 

  341. __cdecl bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff);

  342. __cdecl bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff);

  343. __cdecl bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff);

  344. __cdecl bool jackbridge_port_monitoring_input(jack_port_t* port);

  345. 

  346. __cdecl bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);

  347. __cdecl bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);

  348. __cdecl bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port);

  349. 

  350. __cdecl int    jackbridge_port_name_size();

  351. __cdecl int    jackbridge_port_type_size();

  352. __cdecl size_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type);

  353. 

  354. __cdecl void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);

  355. __cdecl void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);

  356. __cdecl bool jackbridge_recompute_total_latencies(jack_client_t* client);

  357. 

  358. __cdecl const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, ulong flags);

  359. __cdecl jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);

  360. __cdecl jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);

  361. 

  362. __cdecl void jackbridge_free(void* ptr);

  363. 

  364. __cdecl uint32_t jackbridge_midi_get_event_count(void* port_buffer);

  365. __cdecl bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);

  366. __cdecl void     jackbridge_midi_clear_buffer(void* port_buffer);

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

  368. __cdecl jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size);

  369. 

  370. __cdecl bool jackbridge_release_timebase(jack_client_t* client);

  371. __cdecl bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg);

  372. __cdecl bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout);

  373. __cdecl bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg);

  374. __cdecl bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);

  375. 

  376. __cdecl jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);

  377. __cdecl jack_nframes_t         jackbridge_get_current_transport_frame(const jack_client_t* client);

  378. 

  379. __cdecl bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos);

  380. __cdecl void jackbridge_transport_start(jack_client_t* client);

  381. __cdecl void jackbridge_transport_stop(jack_client_t* client);

  382. 

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

  384. __cdecl bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type);

  385. __cdecl void jackbridge_free_description(jack_description_t* desc, bool free_description_itself);

  386. __cdecl bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc);

  387. __cdecl bool jackbridge_get_all_properties(jack_description_t** descs);

  388. __cdecl bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);

  389. __cdecl int  jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject);

  390. __cdecl bool jackbridge_remove_all_properties(jack_client_t* client);

  391. __cdecl bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);

  392. 

  393. __cdecl bool jackbridge_sem_init(void* sem) noexcept;

  394. __cdecl void jackbridge_sem_destroy(void* sem) noexcept;

  395. __cdecl bool jackbridge_sem_post(void* sem) noexcept;

  396. __cdecl bool jackbridge_sem_timedwait(void* sem, uint secs, bool* timedOut) noexcept;

  397. 

  398. __cdecl bool  jackbridge_shm_is_valid(const void* shm) noexcept;

  399. __cdecl void  jackbridge_shm_init(void* shm) noexcept;

  400. __cdecl void  jackbridge_shm_attach(void* shm, const char* name) noexcept;

  401. __cdecl void  jackbridge_shm_close(void* shm) noexcept;

  402. __cdecl void* jackbridge_shm_map(void* shm, size_t size) noexcept;

  403. 

  404. #endif // JACKBRIDGE_HPP_INCLUDED