falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
1026 Commits
2 Branches
142MB
Tree: 3672aa48a0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3672aa48a0'
${ noResults }
Cadence/c++/jackbridge/JackBridge.hpp

358 lines
17KB
Raw Blame History 

  1. /*

  2.  * JackBridge

  3.  * Copyright (C) 2013 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. #include "JackBridgeDefines.hpp"

  21. 

  22. #ifdef JACKBRIDGE_DIRECT

  23. # include <jack/jack.h>

  24. # include <jack/midiport.h>

  25. # include <jack/transport.h>

  26. # include <jack/custom.h>

  27. #else

  28. 

  29. #include <cstddef>

  30. 

  31. #ifdef JACKBRIDGE_PROPER_CPP11_SUPPORT

  32. # include <cstdint>

  33. #else

  34. # include <stdint.h>

  35. #endif

  36. 

  37. #ifndef POST_PACKED_STRUCTURE

  38. # ifdef __GNUC__

  39.   /* POST_PACKED_STRUCTURE needs to be a macro which

  40.       expands into a compiler directive. The directive must

  41.       tell the compiler to arrange the preceding structure

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

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

  44.       compiler.

  45.   */

  46.   #define PRE_PACKED_STRUCTURE

  47.   #define POST_PACKED_STRUCTURE __attribute__((__packed__))

  48. # else

  49.   #ifdef _MSC_VER

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

  51.     #define PRE_PACKED_STRUCTURE    PRE_PACKED_STRUCTURE1

  52.     /* PRE_PACKED_STRUCTURE needs to be a macro which

  53.     expands into a compiler directive. The directive must

  54.     tell the compiler to arrange the following structure

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

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

  57.     compiler.

  58.     */

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

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

  61.     restores the packing to its previous setting */

  62.   #else

  63.     #define PRE_PACKED_STRUCTURE

  64.     #define POST_PACKED_STRUCTURE

  65.   #endif // _MSC_VER

  66. # endif // __GNUC__

  67. #endif

  68. 

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

  70. #define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"

  71. 

  72. #define JACK_HAS_CUSTOM_DATA_API 1

  73. #define JACK_HAS_PORT_IS_CONTROL_VOLTAGE_FLAG 1

  74. 

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

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

  77. #define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode)

  78. #define EXTENDED_TIME_INFO

  79. 

  80. enum JackOptions {

  81.     JackNullOption    = 0x00,

  82.     JackNoStartServer = 0x01,

  83.     JackUseExactName  = 0x02,

  84.     JackServerName    = 0x04,

  85.     JackLoadName      = 0x08,

  86.     JackLoadInit      = 0x10,

  87.     JackSessionID     = 0x20

  88. };

  89. 

  90. enum JackStatus {

  91.     JackFailure       = 0x0001,

  92.     JackInvalidOption = 0x0002,

  93.     JackNameNotUnique = 0x0004,

  94.     JackServerStarted = 0x0008,

  95.     JackServerFailed  = 0x0010,

  96.     JackServerError   = 0x0020,

  97.     JackNoSuchClient  = 0x0040,

  98.     JackLoadFailure   = 0x0080,

  99.     JackInitFailure   = 0x0100,

  100.     JackShmFailure    = 0x0200,

  101.     JackVersionError  = 0x0400,

  102.     JackBackendError  = 0x0800,

  103.     JackClientZombie  = 0x1000

  104. };

  105. 

  106. enum JackLatencyCallbackMode {

  107.     JackCaptureLatency,

  108.     JackPlaybackLatency

  109. };

  110. 

  111. enum JackPortFlags {

  112.     JackPortIsInput    = 0x01,

  113.     JackPortIsOutput   = 0x02,

  114.     JackPortIsPhysical = 0x04,

  115.     JackPortCanMonitor = 0x08,

  116.     JackPortIsTerminal = 0x10,

  117.     JackPortIsControlVoltage = 0x100

  118. };

  119. 

  120. enum JackTransportState {

  121.     JackTransportStopped     = 0,

  122.     JackTransportRolling     = 1,

  123.     JackTransportLooping     = 2,

  124.     JackTransportStarting    = 3,

  125.     JackTransportNetStarting = 4

  126. };

  127. 

  128. enum JackPositionBits {

  129.     JackPositionBBT      = 0x010,

  130.     JackPositionTimecode = 0x020,

  131.     JackBBTFrameOffset   = 0x040,

  132.     JackAudioVideoRatio  = 0x080,

  133.     JackVideoFrameOffset = 0x100

  134. };

  135. 

  136. enum JackSessionEventType {

  137.     JackSessionSave         = 1,

  138.     JackSessionSaveAndQuit  = 2,

  139.     JackSessionSaveTemplate = 3

  140. };

  141. 

  142. enum JackSessionFlags {

  143.     JackSessionSaveError    = 0x1,

  144.     JackSessionNeedTerminal = 0x2

  145. };

  146. 

  147. enum JackCustomChange {

  148.     JackCustomRemoved,

  149.     JackCustomAdded,

  150.     JackCustomReplaced

  151. };

  152. 

  153. typedef uint32_t jack_nframes_t;

  154. typedef uint32_t jack_port_id_t;

  155. typedef uint64_t jack_time_t;

  156. typedef uint64_t jack_unique_t;

  157. typedef unsigned char jack_midi_data_t;

  158. typedef float jack_default_audio_sample_t;

  159. 

  160. typedef enum JackOptions jack_options_t;

  161. typedef enum JackStatus jack_status_t;

  162. typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;

  163. typedef enum JackTransportState jack_transport_state_t;

  164. typedef enum JackPositionBits jack_position_bits_t;

  165. typedef enum JackSessionEventType jack_session_event_type_t;

  166. typedef enum JackSessionFlags jack_session_flags_t;

  167. typedef enum JackCustomChange jack_custom_change_t;

  168. 

  169. struct _jack_midi_event {

  170.     jack_nframes_t    time;

  171.     size_t            size;

  172.     jack_midi_data_t* buffer;

  173. };

  174. 

  175. PRE_PACKED_STRUCTURE

  176. struct _jack_latency_range {

  177.     jack_nframes_t min;

  178.     jack_nframes_t max;

  179. } POST_PACKED_STRUCTURE;

  180. 

  181. PRE_PACKED_STRUCTURE

  182. struct _jack_position {

  183.     jack_unique_t  unique_1;

  184.     jack_time_t    usecs;

  185.     jack_nframes_t frame_rate;

  186.     jack_nframes_t frame;

  187.     jack_position_bits_t valid;

  188.     int32_t bar;

  189.     int32_t beat;

  190.     int32_t tick;

  191.     double  bar_start_tick;

  192.     float   beats_per_bar;

  193.     float   beat_type;

  194.     double  ticks_per_beat;

  195.     double  beats_per_minute;

  196.     double  frame_time;

  197.     double  next_time;

  198.     jack_nframes_t bbt_offset;

  199.     float          audio_frames_per_video_frame;

  200.     jack_nframes_t video_offset;

  201.     int32_t        padding[7];

  202.     jack_unique_t  unique_2;

  203. } POST_PACKED_STRUCTURE;

  204. 

  205. struct _jack_session_event {

  206.     jack_session_event_type_t type;

  207.     const char* session_dir;

  208.     const char* client_uuid;

  209.     char*       command_line;

  210.     jack_session_flags_t flags;

  211.     uint32_t future;

  212. };

  213. 

  214. struct _jack_session_command_t {

  215.     const char* uuid;

  216.     const char* client_name;

  217.     const char* command;

  218.     jack_session_flags_t flags;

  219. };

  220. 

  221. typedef struct _jack_port jack_port_t;

  222. typedef struct _jack_client jack_client_t;

  223. typedef struct _jack_midi_event jack_midi_event_t;

  224. typedef struct _jack_latency_range jack_latency_range_t;

  225. typedef struct _jack_position jack_position_t;

  226. typedef struct _jack_session_event jack_session_event_t;

  227. typedef struct _jack_session_command_t jack_session_command_t;

  228. 

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

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

  231. typedef void (*JackThreadInitCallback)(void* arg);

  232. typedef int  (*JackGraphOrderCallback)(void* arg);

  233. typedef int  (*JackXRunCallback)(void* arg);

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

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

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

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

  238. typedef int  (*JackClientRenameCallback)(const char* old_name, const char* new_name, void* arg);

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

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

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

  242. typedef void (*JackShutdownCallback)(void* arg);

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

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

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

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

  247. typedef void (*JackCustomDataAppearanceCallback)(const char* client_name, const char* key, jack_custom_change_t change, void* arg);

  248. 

  249. #endif // ! JACKBRIDGE_DIRECT

  250. 

  251. JACKBRIDGE_EXPORT void        jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);

  252. JACKBRIDGE_EXPORT const char* jackbridge_get_version_string();

  253. 

  254. JACKBRIDGE_EXPORT jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...);

  255. JACKBRIDGE_EXPORT const char*    jackbridge_client_rename(jack_client_t* client, const char* new_name);

  256. JACKBRIDGE_EXPORT bool           jackbridge_client_close(jack_client_t* client);

  257. 

  258. JACKBRIDGE_EXPORT int   jackbridge_client_name_size();

  259. JACKBRIDGE_EXPORT char* jackbridge_get_client_name(jack_client_t* client);

  260. 

  261. JACKBRIDGE_EXPORT bool jackbridge_activate(jack_client_t* client);

  262. JACKBRIDGE_EXPORT bool jackbridge_deactivate(jack_client_t* client);

  263. 

  264. JACKBRIDGE_EXPORT int  jackbridge_get_client_pid(const char* name);

  265. JACKBRIDGE_EXPORT bool jackbridge_is_realtime(jack_client_t* client);

  266. 

  267. JACKBRIDGE_EXPORT bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);

  268. JACKBRIDGE_EXPORT void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);

  269. JACKBRIDGE_EXPORT void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);

  270. JACKBRIDGE_EXPORT bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);

  271. JACKBRIDGE_EXPORT bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);

  272. JACKBRIDGE_EXPORT bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);

  273. JACKBRIDGE_EXPORT bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);

  274. JACKBRIDGE_EXPORT bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);

  275. JACKBRIDGE_EXPORT bool jackbridge_set_client_rename_callback(jack_client_t* client, JackClientRenameCallback rename_callback, void* arg);

  276. JACKBRIDGE_EXPORT bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);

  277. JACKBRIDGE_EXPORT bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);

  278. JACKBRIDGE_EXPORT bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);

  279. JACKBRIDGE_EXPORT bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);

  280. JACKBRIDGE_EXPORT bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);

  281. JACKBRIDGE_EXPORT bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);

  282. 

  283. JACKBRIDGE_EXPORT bool jackbridge_set_freewheel(jack_client_t* client, bool onoff);

  284. JACKBRIDGE_EXPORT bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);

  285. 

  286. JACKBRIDGE_EXPORT jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);

  287. JACKBRIDGE_EXPORT jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);

  288. JACKBRIDGE_EXPORT float          jackbridge_cpu_load(jack_client_t* client);

  289. 

  290. JACKBRIDGE_EXPORT jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);

  291. JACKBRIDGE_EXPORT bool         jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);

  292. JACKBRIDGE_EXPORT void*        jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

  293. 

  294. JACKBRIDGE_EXPORT const char*  jackbridge_port_name(const jack_port_t* port);

  295. JACKBRIDGE_EXPORT const char*  jackbridge_port_short_name(const jack_port_t* port);

  296. JACKBRIDGE_EXPORT int          jackbridge_port_flags(const jack_port_t* port);

  297. JACKBRIDGE_EXPORT const char*  jackbridge_port_type(const jack_port_t* port);

  298. JACKBRIDGE_EXPORT bool         jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);

  299. JACKBRIDGE_EXPORT bool         jackbridge_port_connected(const jack_port_t* port);

  300. JACKBRIDGE_EXPORT bool         jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);

  301. JACKBRIDGE_EXPORT const char** jackbridge_port_get_connections(const jack_port_t* port);

  302. JACKBRIDGE_EXPORT const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);

  303. 

  304. JACKBRIDGE_EXPORT bool jackbridge_port_set_name(jack_port_t* port, const char* port_name);

  305. JACKBRIDGE_EXPORT bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);

  306. JACKBRIDGE_EXPORT bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);

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

  308. 

  309. JACKBRIDGE_EXPORT bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff);

  310. JACKBRIDGE_EXPORT bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff);

  311. JACKBRIDGE_EXPORT bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff);

  312. JACKBRIDGE_EXPORT bool jackbridge_port_monitoring_input(jack_port_t* port);

  313. 

  314. JACKBRIDGE_EXPORT bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);

  315. JACKBRIDGE_EXPORT bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);

  316. JACKBRIDGE_EXPORT bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port);

  317. 

  318. JACKBRIDGE_EXPORT int    jackbridge_port_name_size();

  319. JACKBRIDGE_EXPORT int    jackbridge_port_type_size();

  320. JACKBRIDGE_EXPORT size_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type);

  321. 

  322. JACKBRIDGE_EXPORT void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);

  323. JACKBRIDGE_EXPORT void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);

  324. JACKBRIDGE_EXPORT bool jackbridge_recompute_total_latencies(jack_client_t* client);

  325. 

  326. JACKBRIDGE_EXPORT const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags);

  327. JACKBRIDGE_EXPORT jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);

  328. JACKBRIDGE_EXPORT jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);

  329. 

  330. JACKBRIDGE_EXPORT void jackbridge_free(void* ptr);

  331. 

  332. JACKBRIDGE_EXPORT uint32_t jackbridge_midi_get_event_count(void* port_buffer);

  333. JACKBRIDGE_EXPORT bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);

  334. JACKBRIDGE_EXPORT void     jackbridge_midi_clear_buffer(void* port_buffer);

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

  336. JACKBRIDGE_EXPORT jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size);

  337. 

  338. JACKBRIDGE_EXPORT bool jackbridge_release_timebase(jack_client_t* client);

  339. JACKBRIDGE_EXPORT bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg);

  340. JACKBRIDGE_EXPORT bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout);

  341. JACKBRIDGE_EXPORT bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg);

  342. JACKBRIDGE_EXPORT bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);

  343. 

  344. JACKBRIDGE_EXPORT jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);

  345. JACKBRIDGE_EXPORT jack_nframes_t         jackbridge_get_current_transport_frame(const jack_client_t* client);

  346. 

  347. JACKBRIDGE_EXPORT bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos);

  348. JACKBRIDGE_EXPORT void jackbridge_transport_start(jack_client_t* client);

  349. JACKBRIDGE_EXPORT void jackbridge_transport_stop(jack_client_t* client);

  350. 

  351. JACKBRIDGE_EXPORT bool jackbridge_custom_publish_data(jack_client_t* client, const char* key, const void* data, size_t size);

  352. JACKBRIDGE_EXPORT bool jackbridge_custom_get_data(jack_client_t* client, const char* client_name, const char* key, void** data, size_t* size);

  353. JACKBRIDGE_EXPORT bool jackbridge_custom_unpublish_data(jack_client_t* client, const char* key);

  354. JACKBRIDGE_EXPORT bool jackbridge_custom_set_data_appearance_callback(jack_client_t* client, JackCustomDataAppearanceCallback callback, void* arg);

  355. JACKBRIDGE_EXPORT const char** jackbridge_custom_get_keys(jack_client_t* client, const char* client_name);

  356. 

  357. #endif // JACKBRIDGE_HPP_INCLUDED