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.
926 Commits
2 Branches
42MB
Tree: a552c190eb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a552c190eb'
${ noResults }
Cadence/c++/jackbridge/JackBridge.hpp

344 lines
15KB
Raw Blame History 

  1. /*

  2.  * JackBridge

  3.  * Copyright (C) 2013 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #ifndef __JACKBRIDGE_HPP__

  19. #define __JACKBRIDGE_HPP__

  20. 

  21. #include "CarlaDefines.hpp"

  22. 

  23. #ifndef JACKBRIDGE_EXPORT

  24. # undef CARLA_EXPORT

  25. # define CARLA_EXPORT

  26. #endif

  27. 

  28. #ifdef JACKBRIDGE_DIRECT

  29. # include <jack/jack.h>

  30. # include <jack/midiport.h>

  31. # include <jack/transport.h>

  32. # include <jack/custom.h>

  33. #else

  34. 

  35. #include <cstddef>

  36. 

  37. #ifdef CARLA_PROPER_CPP11_SUPPORT

  38. # include <cstdint>

  39. #else

  40. # include <stdint.h>

  41. #endif

  42. 

  43. #ifndef POST_PACKED_STRUCTURE

  44. # ifdef __GNUC__

  45.   /* POST_PACKED_STRUCTURE needs to be a macro which

  46.       expands into a compiler directive. The directive must

  47.       tell the compiler to arrange the preceding structure

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

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

  50.       compiler.

  51.   */

  52.   #define PRE_PACKED_STRUCTURE

  53.   #define POST_PACKED_STRUCTURE __attribute__((__packed__))

  54. # else

  55.   #ifdef _MSC_VER

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

  57.     #define PRE_PACKED_STRUCTURE    PRE_PACKED_STRUCTURE1

  58.     /* PRE_PACKED_STRUCTURE needs to be a macro which

  59.     expands into a compiler directive. The directive must

  60.     tell the compiler to arrange the following structure

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

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

  63.     compiler.

  64.     */

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

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

  67.     restores the packing to its previous setting */

  68.   #else

  69.     #define PRE_PACKED_STRUCTURE

  70.     #define POST_PACKED_STRUCTURE

  71.   #endif // _MSC_VER

  72. # endif // __GNUC__

  73. #endif

  74. 

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

  76. #define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"

  77. 

  78. #define JACK_HAS_CUSTOM_DATA_API 1

  79. #define JACK_HAS_PORT_IS_CONTROL_VOLTAGE_FLAG 1

  80. 

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

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

  83. #define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode)

  84. #define EXTENDED_TIME_INFO

  85. 

  86. enum JackOptions {

  87.     JackNullOption    = 0x00,

  88.     JackNoStartServer = 0x01,

  89.     JackUseExactName  = 0x02,

  90.     JackServerName    = 0x04,

  91.     JackLoadName      = 0x08,

  92.     JackLoadInit      = 0x10,

  93.     JackSessionID     = 0x20

  94. };

  95. 

  96. enum JackStatus {

  97.     JackFailure       = 0x01,

  98.     JackInvalidOption = 0x02,

  99.     JackNameNotUnique = 0x04,

  100.     JackServerStarted = 0x08,

  101.     JackServerFailed  = 0x10,

  102.     JackServerError   = 0x20,

  103.     JackNoSuchClient  = 0x40,

  104.     JackLoadFailure   = 0x80,

  105.     JackInitFailure   = 0x100,

  106.     JackShmFailure    = 0x200,

  107.     JackVersionError  = 0x400,

  108.     JackBackendError  = 0x800,

  109.     JackClientZombie  = 0x1000

  110. };

  111. 

  112. enum JackLatencyCallbackMode {

  113.     JackCaptureLatency,

  114.     JackPlaybackLatency

  115. };

  116. 

  117. enum JackPortFlags {

  118.     JackPortIsInput    = 0x1,

  119.     JackPortIsOutput   = 0x2,

  120.     JackPortIsPhysical = 0x4,

  121.     JackPortCanMonitor = 0x8,

  122.     JackPortIsTerminal = 0x10,

  123.     JackPortIsControlVoltage = 0x100

  124. };

  125. 

  126. enum JackTransportState {

  127.     JackTransportStopped     = 0,

  128.     JackTransportRolling     = 1,

  129.     JackTransportLooping     = 2,

  130.     JackTransportStarting    = 3,

  131.     JackTransportNetStarting = 4

  132. };

  133. 

  134. enum JackPositionBits {

  135.     JackPositionBBT      = 0x010,

  136.     JackPositionTimecode = 0x020,

  137.     JackBBTFrameOffset   = 0x040,

  138.     JackAudioVideoRatio  = 0x080,

  139.     JackVideoFrameOffset = 0x100

  140. };

  141. 

  142. enum JackSessionEventType {

  143.     JackSessionSave         = 1,

  144.     JackSessionSaveAndQuit  = 2,

  145.     JackSessionSaveTemplate = 3

  146. };

  147. 

  148. enum JackSessionFlags {

  149.     JackSessionSaveError    = 0x01,

  150.     JackSessionNeedTerminal = 0x02

  151. };

  152. 

  153. enum JackCustomChange {

  154.     JackCustomRemoved,

  155.     JackCustomAdded,

  156.     JackCustomReplaced

  157. };

  158. 

  159. typedef uint32_t jack_nframes_t;

  160. typedef uint32_t jack_port_id_t;

  161. typedef uint64_t jack_time_t;

  162. typedef uint64_t jack_unique_t;

  163. typedef unsigned char jack_midi_data_t;

  164. typedef float jack_default_audio_sample_t;

  165. 

  166. typedef enum JackOptions jack_options_t;

  167. typedef enum JackStatus jack_status_t;

  168. typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;

  169. typedef enum JackTransportState jack_transport_state_t;

  170. typedef enum JackPositionBits jack_position_bits_t;

  171. typedef enum JackSessionEventType jack_session_event_type_t;

  172. typedef enum JackSessionFlags jack_session_flags_t;

  173. typedef enum JackCustomChange jack_custom_change_t;

  174. 

  175. struct _jack_midi_event {

  176.     jack_nframes_t    time;

  177.     size_t            size;

  178.     jack_midi_data_t* buffer;

  179. };

  180. 

  181. PRE_PACKED_STRUCTURE

  182. struct _jack_latency_range {

  183.     jack_nframes_t min;

  184.     jack_nframes_t max;

  185. } POST_PACKED_STRUCTURE;

  186. 

  187. PRE_PACKED_STRUCTURE

  188. struct _jack_position {

  189.     jack_unique_t  unique_1;

  190.     jack_time_t    usecs;

  191.     jack_nframes_t frame_rate;

  192.     jack_nframes_t frame;

  193.     jack_position_bits_t valid;

  194.     int32_t bar;

  195.     int32_t beat;

  196.     int32_t tick;

  197.     double  bar_start_tick;

  198.     float   beats_per_bar;

  199.     float   beat_type;

  200.     double  ticks_per_beat;

  201.     double  beats_per_minute;

  202.     double  frame_time;

  203.     double  next_time;

  204.     jack_nframes_t bbt_offset;

  205.     float          audio_frames_per_video_frame;

  206.     jack_nframes_t video_offset;

  207.     int32_t        padding[7];

  208.     jack_unique_t  unique_2;

  209. } POST_PACKED_STRUCTURE;

  210. 

  211. struct _jack_session_event {

  212.     jack_session_event_type_t type;

  213.     const char* session_dir;

  214.     const char* client_uuid;

  215.     char*       command_line;

  216.     jack_session_flags_t flags;

  217.     uint32_t future;

  218. };

  219. 

  220. struct _jack_session_command_t {

  221.     const char* uuid;

  222.     const char* client_name;

  223.     const char* command;

  224.     jack_session_flags_t flags;

  225. };

  226. 

  227. typedef struct _jack_port jack_port_t;

  228. typedef struct _jack_client jack_client_t;

  229. typedef struct _jack_midi_event jack_midi_event_t;

  230. typedef struct _jack_latency_range jack_latency_range_t;

  231. typedef struct _jack_position jack_position_t;

  232. typedef struct _jack_session_event jack_session_event_t;

  233. typedef struct _jack_session_command_t jack_session_command_t;

  234. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  254. 

  255. #endif // ! JACKBRIDGE_DIRECT

  256. 

  257. CARLA_EXPORT const char*    jackbridge_get_version_string();

  258. CARLA_EXPORT jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...);

  259. CARLA_EXPORT const char*    jackbridge_client_rename(jack_client_t* client, const char* new_name);

  260. 

  261. CARLA_EXPORT bool  jackbridge_client_close(jack_client_t* client);

  262. CARLA_EXPORT int   jackbridge_client_name_size();

  263. CARLA_EXPORT char* jackbridge_get_client_name(jack_client_t* client);

  264. 

  265. CARLA_EXPORT bool jackbridge_activate(jack_client_t* client);

  266. CARLA_EXPORT bool jackbridge_deactivate(jack_client_t* client);

  267. 

  268. CARLA_EXPORT int jackbridge_get_client_pid(const char* name);

  269. CARLA_EXPORT int jackbridge_is_realtime(jack_client_t* client);

  270. 

  271. CARLA_EXPORT bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);

  272. CARLA_EXPORT void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);

  273. CARLA_EXPORT void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);

  274. CARLA_EXPORT bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);

  275. CARLA_EXPORT bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);

  276. CARLA_EXPORT bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);

  277. CARLA_EXPORT bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);

  278. CARLA_EXPORT bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);

  279. #ifndef JACKBRIDGE_DIRECT

  280. CARLA_EXPORT bool jackbridge_set_client_rename_callback(jack_client_t* client, JackClientRenameCallback registration_callback, void* arg);

  281. #endif

  282. CARLA_EXPORT bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);

  283. CARLA_EXPORT bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);

  284. CARLA_EXPORT bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);

  285. CARLA_EXPORT bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);

  286. CARLA_EXPORT bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);

  287. CARLA_EXPORT bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);

  288. 

  289. CARLA_EXPORT bool  jackbridge_set_freewheel(jack_client_t* client, int onoff);

  290. CARLA_EXPORT bool  jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);

  291. CARLA_EXPORT bool  jackbridge_engine_takeover_timebase(jack_client_t* client);

  292. CARLA_EXPORT float jackbridge_cpu_load(jack_client_t* client);

  293. 

  294. CARLA_EXPORT jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);

  295. CARLA_EXPORT jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);

  296. 

  297. CARLA_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);

  298. 

  299. CARLA_EXPORT bool  jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);

  300. CARLA_EXPORT void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

  301. 

  302. CARLA_EXPORT const char*  jackbridge_port_name(const jack_port_t* port);

  303. CARLA_EXPORT const char*  jackbridge_port_short_name(const jack_port_t* port);

  304. CARLA_EXPORT int          jackbridge_port_flags(const jack_port_t* port);

  305. CARLA_EXPORT const char*  jackbridge_port_type(const jack_port_t* port);

  306. CARLA_EXPORT bool         jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);

  307. CARLA_EXPORT bool         jackbridge_port_connected(const jack_port_t* port);

  308. CARLA_EXPORT bool         jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);

  309. CARLA_EXPORT const char** jackbridge_port_get_connections(const jack_port_t* port);

  310. CARLA_EXPORT const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);

  311. 

  312. CARLA_EXPORT bool jackbridge_port_set_name(jack_port_t* port, const char* port_name);

  313. CARLA_EXPORT bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);

  314. CARLA_EXPORT bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);

  315. CARLA_EXPORT int  jackbridge_port_name_size();

  316. CARLA_EXPORT void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);

  317. CARLA_EXPORT void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);

  318. CARLA_EXPORT bool jackbridge_recompute_total_latencies(jack_client_t* client);

  319. 

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

  321. CARLA_EXPORT jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);

  322. CARLA_EXPORT jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);

  323. 

  324. CARLA_EXPORT void jackbridge_free(void* ptr);

  325. 

  326. CARLA_EXPORT uint32_t jackbridge_midi_get_event_count(void* port_buffer);

  327. CARLA_EXPORT bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);

  328. CARLA_EXPORT void     jackbridge_midi_clear_buffer(void* port_buffer);

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

  330. CARLA_EXPORT jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size);

  331. 

  332. CARLA_EXPORT int  jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);

  333. CARLA_EXPORT void jackbridge_transport_start(jack_client_t* client);

  334. CARLA_EXPORT void jackbridge_transport_stop(jack_client_t* client);

  335. CARLA_EXPORT jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);

  336. 

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

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

  339. CARLA_EXPORT bool jackbridge_custom_unpublish_data(jack_client_t* client, const char* key);

  340. CARLA_EXPORT bool jackbridge_custom_set_data_appearance_callback(jack_client_t* client, JackCustomDataAppearanceCallback callback, void* arg);

  341. CARLA_EXPORT const char** jackbridge_custom_get_keys(jack_client_t* client, const char* client_name);

  342. 

  343. #endif // __JACKBRIDGE_HPP__