wineasio/jackbridge.h

/*
 * JackBridge for DPF
 * Copyright (C) 2013-2025 Filipe Coelho <falktx@falktx.com>
 *
 * Permission to use, copy, modify, and/or distribute this software for any purpose with
 * or without fee is hereby granted, provided that the above copyright notice and this
 * permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
 * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#pragma once

#include <pthread.h>

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#define PRE_PACKED_STRUCTURE
#define POST_PACKED_STRUCTURE __attribute__((__packed__))

#define JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"
#define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"

#define JACK_MAX_FRAMES (4294967295U)

#define JackOpenOptions (JackSessionID|JackServerName|JackNoStartServer|JackUseExactName)
#define JackLoadOptions (JackLoadInit|JackLoadName|JackUseExactName)

#define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode|JackBBTFrameOffset|JackAudioVideoRatio|JackVideoFrameOffset)
#define EXTENDED_TIME_INFO

#define JACK_UUID_SIZE 36
#define JACK_UUID_STRING_SIZE (JACK_UUID_SIZE+1) /* includes trailing null */
#define JACK_UUID_EMPTY_INITIALIZER 0

#define JACK_TICK_DOUBLE

enum JackOptions {
    JackNullOption    = 0x00,
    JackNoStartServer = 0x01,
    JackUseExactName  = 0x02,
    JackServerName    = 0x04,
    JackLoadName      = 0x08,
    JackLoadInit      = 0x10,
    JackSessionID     = 0x20
};

enum JackStatus {
    JackFailure       = 0x0001,
    JackInvalidOption = 0x0002,
    JackNameNotUnique = 0x0004,
    JackServerStarted = 0x0008,
    JackServerFailed  = 0x0010,
    JackServerError   = 0x0020,
    JackNoSuchClient  = 0x0040,
    JackLoadFailure   = 0x0080,
    JackInitFailure   = 0x0100,
    JackShmFailure    = 0x0200,
    JackVersionError  = 0x0400,
    JackBackendError  = 0x0800,
    JackClientZombie  = 0x1000,
    JackBridgeNativeFailed = 0x10000
};

enum JackLatencyCallbackMode {
    JackCaptureLatency,
    JackPlaybackLatency
};

enum JackPortFlags {
    JackPortIsInput    = 0x01,
    JackPortIsOutput   = 0x02,
    JackPortIsPhysical = 0x04,
    JackPortCanMonitor = 0x08,
    JackPortIsTerminal = 0x10,
    JackPortIsControlVoltage = 0x20
};

enum JackTransportState {
    JackTransportStopped  = 0,
    JackTransportRolling  = 1,
    JackTransportLooping  = 2,
    JackTransportStarting = 3
};

enum JackPositionBits {
    JackPositionBBT      = 0x010,
    JackPositionTimecode = 0x020,
    JackBBTFrameOffset   = 0x040,
    JackAudioVideoRatio  = 0x080,
    JackVideoFrameOffset = 0x100,
    JackTickDouble       = 0x200
};

enum JackSessionEventType {
    JackSessionSave         = 1,
    JackSessionSaveAndQuit  = 2,
    JackSessionSaveTemplate = 3
};

enum JackSessionFlags {
    JackSessionSaveError    = 0x1,
    JackSessionNeedTerminal = 0x2
};

enum JackPropertyChange {
    PropertyCreated,
    PropertyChanged,
    PropertyDeleted
};

typedef uint32_t jack_nframes_t;
typedef uint32_t jack_port_id_t;
typedef uint64_t jack_time_t;
typedef uint64_t jack_uuid_t;
typedef uint64_t jack_unique_t;
typedef unsigned char jack_midi_data_t;
typedef float jack_default_audio_sample_t;

typedef enum JackOptions jack_options_t;
typedef enum JackStatus jack_status_t;
typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;
typedef enum JackTransportState jack_transport_state_t;
typedef enum JackPositionBits jack_position_bits_t;
typedef enum JackSessionEventType jack_session_event_type_t;
typedef enum JackSessionFlags jack_session_flags_t;
typedef enum JackPropertyChange jack_property_change_t;

struct _jack_midi_event {
    jack_nframes_t    time;
    size_t            size;
    jack_midi_data_t* buffer;
};

// NOTE: packed in JACK2 but not in JACK1
PRE_PACKED_STRUCTURE
struct _jack_latency_range {
    jack_nframes_t min;
    jack_nframes_t max;
} POST_PACKED_STRUCTURE;

PRE_PACKED_STRUCTURE
struct _jack_position {
    jack_unique_t  unique_1;
    jack_time_t    usecs;
    jack_nframes_t frame_rate;
    jack_nframes_t frame;
    jack_position_bits_t valid;
    int32_t bar;
    int32_t beat;
    int32_t tick;
    double  bar_start_tick;
    float   beats_per_bar;
    float   beat_type;
    double  ticks_per_beat;
    double  beats_per_minute;
    double  frame_time;
    double  next_time;
    jack_nframes_t bbt_offset;
    float          audio_frames_per_video_frame;
    jack_nframes_t video_offset;
    double         tick_double;
    int32_t        padding[5];
    jack_unique_t  unique_2;
} POST_PACKED_STRUCTURE;

struct _jack_session_event {
    jack_session_event_type_t type;
    const char* session_dir;
    const char* client_uuid;
    char*       command_line;
    jack_session_flags_t flags;
    uint32_t future;
};

struct _jack_session_command_t {
    const char* uuid;
    const char* client_name;
    const char* command;
    jack_session_flags_t flags;
};

typedef struct {
    const char* key;
    const char* data;
    const char* type;
} jack_property_t;

typedef struct {
    jack_uuid_t      subject;
    uint32_t         property_cnt;
    jack_property_t* properties;
    uint32_t         property_size;
} jack_description_t;

typedef struct _jack_port jack_port_t;
typedef struct _jack_client jack_client_t;
typedef struct _jack_midi_event jack_midi_event_t;
typedef struct _jack_latency_range jack_latency_range_t;
typedef struct _jack_position jack_position_t;
typedef struct _jack_session_event jack_session_event_t;
typedef struct _jack_session_command_t jack_session_command_t;

typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);
typedef int  (*JackProcessCallback)(jack_nframes_t nframes, void* arg);
typedef void (*JackThreadInitCallback)(void* arg);
typedef int  (*JackGraphOrderCallback)(void* arg);
typedef int  (*JackXRunCallback)(void* arg);
typedef int  (*JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);
typedef int  (*JackSampleRateCallback)(jack_nframes_t nframes, void* arg);
typedef void (*JackPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg);
typedef void (*JackClientRegistrationCallback)(const char* name, int register_, void* arg);
typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
typedef void (*JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg);
typedef void (*JackFreewheelCallback)(int starting, void* arg);
typedef void (*JackShutdownCallback)(void* arg);
typedef void (*JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);
typedef int  (*JackSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg);
typedef void (*JackTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg);
typedef void (*JackSessionCallback)(jack_session_event_t* event, void* arg);
typedef void (*JackPropertyChangeCallback)(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg);
typedef void *(*JackThreadCallback)(void* arg);
typedef int  (*JackThreadCreator)(pthread_t*, const pthread_attr_t*, void *(*)(void*), void*);

bool jackbridge_is_ok();

void        jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);
const char* jackbridge_get_version_string();

jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status);
bool           jackbridge_client_close(jack_client_t* client);

int         jackbridge_client_name_size();
const char* jackbridge_get_client_name(jack_client_t* client);

char* jackbridge_client_get_uuid(jack_client_t* client);
char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name);
char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid);

bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid);
void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE]);

bool jackbridge_activate(jack_client_t* client);
bool jackbridge_deactivate(jack_client_t* client);
bool jackbridge_is_realtime(jack_client_t* client);

bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);
void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);
void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);
bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);
bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);
bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);
bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);
bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);
bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);
bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);
bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);
bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);
bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);
bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);

bool jackbridge_set_freewheel(jack_client_t* client, bool onoff);
bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);

jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);
jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);
float          jackbridge_cpu_load(jack_client_t* client);

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);
bool         jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);
void*        jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

const char*  jackbridge_port_name(const jack_port_t* port);
jack_uuid_t  jackbridge_port_uuid(const jack_port_t* port);
const char*  jackbridge_port_short_name(const jack_port_t* port);
int          jackbridge_port_flags(const jack_port_t* port);
const char*  jackbridge_port_type(const jack_port_t* port);
bool         jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);
int          jackbridge_port_connected(const jack_port_t* port);
bool         jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);
const char** jackbridge_port_get_connections(const jack_port_t* port);
const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);

bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name);
bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);
bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);
int  jackbridge_port_get_aliases(const jack_port_t* port, char* const al[2]);

bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff);
bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff);
bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff);
bool jackbridge_port_monitoring_input(jack_port_t* port);

bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);
bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);
bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port);

int      jackbridge_port_name_size();
int      jackbridge_port_type_size();
uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type);

void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);
void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);
bool jackbridge_recompute_total_latencies(jack_client_t* client);

const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags);
jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);
jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);

void jackbridge_free(void* ptr);

uint32_t jackbridge_midi_get_event_count(void* port_buffer);
bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);
void     jackbridge_midi_clear_buffer(void* port_buffer);
bool     jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size);
jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size);

bool jackbridge_release_timebase(jack_client_t* client);
bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg);
bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout);
bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg);
bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);

uint32_t       jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);
jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client);

bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos);
void jackbridge_transport_start(jack_client_t* client);
void jackbridge_transport_stop(jack_client_t* client);

bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type);
bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type);
void jackbridge_free_description(jack_description_t* desc, bool free_description_itself);
bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc);
bool jackbridge_get_all_properties(jack_description_t** descs);
bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);
int  jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject);
bool jackbridge_remove_all_properties(jack_client_t* client);
bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);

void jackbridge_set_thread_creator(JackThreadCreator creator);

bool jackbridge_set_process_thread(jack_client_t* client, JackThreadCallback callback, void* arg);
jack_nframes_t jackbridge_cycle_wait(jack_client_t* client);
void jackbridge_cycle_signal(jack_client_t* client, int status);

jack_nframes_t jackbridge_port_get_latency(jack_port_t* port);
jack_nframes_t jackbridge_frame_time(const jack_client_t* client);