WineASIO
/
wineasio
mirror of https://github.com/wineasio/wineasio
1
0
Fork 0
Code Releases 4 Activity
Browse Source

Load libjack.so.0 dynamically at runtime, removing build dep 

Signed-off-by: falkTX <falktx@falktx.com>
tags/v1.3.0
falkTX 3 months ago
parent
22baa697e1
commit
eb35e014f1
Signed by: falkTX <falktx@falktx.com> GPG Key ID: CDBAA37ABC74FBA0
4 changed files with 1617 additions and 55 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -11
      Makefile.mk
  2. +45
    -44
      asio.c
  3. +1214
    -0
      jackbridge.c
  4. +355
    -0
      jackbridge.h

+ 3
- 11
Makefile.mk View File

@@ -40,7 +40,6 @@ INCLUDE_PATH += -I/opt/wine-stable/include
INCLUDE_PATH += -I/opt/wine-stable/include/wine/windows
INCLUDE_PATH += -I/opt/wine-staging/include
INCLUDE_PATH += -I/opt/wine-staging/include/wine/windows
LIBRARIES = $(shell pkg-config --libs jack)

# Debug or Release
ifeq ($(DEBUG),true)
@@ -52,6 +51,7 @@ endif
### wineasio.dll settings

wineasio_dll_C_SRCS = asio.c \
jackbridge.c \
main.c \
regsvr.c
wineasio_dll_LDFLAGS = -shared \
@@ -69,17 +69,9 @@ wineasio_dll_LDFLAGS = -shared \
-L/opt/wine-staging/lib/wine \
-L/opt/wine-staging/lib$(M) \
-L/opt/wine-staging/lib$(M)/wine
wineasio_dll_DLLS = odbc32 \
ole32 \
winmm
wineasio_dll_LIBRARIES = uuid

wineasio_dll_OBJS = $(wineasio_dll_C_SRCS:%.c=build$(M)/%.c.o)

### Global source lists

C_SRCS = $(wineasio_dll_C_SRCS)

### Generic targets

all:
@@ -101,5 +93,5 @@ build$(M)/$(wineasio_dll_MODULE): $(wineasio_dll_OBJS)
$(WINEBUILD) -m$(M) --dll --fake-module -E wineasio.dll.spec $^ -o $@

build$(M)/$(wineasio_dll_MODULE).so: $(wineasio_dll_OBJS)
$(WINECC) $^ $(wineasio_dll_LDFLAGS) $(LIBRARIES) \
$(wineasio_dll_DLLS:%=-l%) $(wineasio_dll_LIBRARIES:%=-l%) -o $@
$(WINECC) $^ $(wineasio_dll_LDFLAGS) \
-lodbc32 -lole32 -luuid -lwinmm -o $@

+ 45
- 44
asio.c View File

@@ -31,24 +31,24 @@
#include <unistd.h>
#include <sys/mman.h>
#include <pthread.h>
#include <jack/jack.h>
#include <jack/thread.h>

#ifdef DEBUG
#include "wine/debug.h"
#else
#define TRACE(...) {}
#define WARN(fmt, ...) {} fprintf(stdout, fmt, ##__VA_ARGS__)
#define ERR(fmt, ...) {} fprintf(stderr, fmt, ##__VA_ARGS__)
#define WARN(fmt, ...) {} fprintf(stdout, "[wineasio] " fmt, ##__VA_ARGS__)
#define ERR(fmt, ...) {} fprintf(stderr, "[wineasio] " fmt, ##__VA_ARGS__)
#endif

#include "objbase.h"
#include "mmsystem.h"
#include "winreg.h"
#include <objbase.h>
#include <mmsystem.h>
#include <winreg.h>
#ifdef WINE_WITH_UNICODE
#include "wine/unicode.h"
#include <wine/unicode.h>
#endif

#include "jackbridge.h"

#ifdef DEBUG
WINE_DEFAULT_DEBUG_CHANNEL(asio);
#endif
@@ -412,22 +412,22 @@ HIDDEN ULONG STDMETHODCALLTYPE Release(LPWINEASIO iface)
/* just for good measure we deinitialize IOChannel structures and unregister JACK ports */
for (int i = 0; i < This->wineasio_number_inputs; i++)
{
jack_port_unregister (This->jack_client, This->input_channel[i].port);
jackbridge_port_unregister (This->jack_client, This->input_channel[i].port);
This->input_channel[i].active = false;
This->input_channel[i].port = NULL;
}
for (int i = 0; i < This->wineasio_number_outputs; i++)
{
jack_port_unregister (This->jack_client, This->output_channel[i].port);
jackbridge_port_unregister (This->jack_client, This->output_channel[i].port);
This->output_channel[i].active = false;
This->output_channel[i].port = NULL;
}
This->host_active_inputs = This->host_active_outputs = 0;
TRACE("%i IOChannel structures released\n", This->wineasio_number_inputs + This->wineasio_number_outputs);

jack_free (This->jack_output_ports);
jack_free (This->jack_input_ports);
jack_client_close(This->jack_client);
jackbridge_free (This->jack_output_ports);
jackbridge_free (This->jack_input_ports);
jackbridge_client_close(This->jack_client);
if (This->input_channel)
HeapFree(GetProcessHeap(), 0, This->input_channel);
}
@@ -457,21 +457,21 @@ HIDDEN LONG STDMETHODCALLTYPE Init(LPWINEASIO iface, void *sysRef)
mlockall(MCL_FUTURE);
configure_driver(This);

if (!(This->jack_client = jack_client_open(This->jack_client_name, jack_options, &jack_status)))
if (!(This->jack_client = jackbridge_client_open(This->jack_client_name, jack_options, &jack_status)))
{
WARN("Unable to open a JACK client as: %s\n", This->jack_client_name);
return 0;
}
TRACE("JACK client opened as: '%s'\n", jack_get_client_name(This->jack_client));
TRACE("JACK client opened as: '%s'\n", jackbridge_get_client_name(This->jack_client));

This->host_sample_rate = jack_get_sample_rate(This->jack_client);
This->host_current_buffersize = jack_get_buffer_size(This->jack_client);
This->host_sample_rate = jackbridge_get_sample_rate(This->jack_client);
This->host_current_buffersize = jackbridge_get_buffer_size(This->jack_client);

/* Allocate IOChannel structures */
This->input_channel = HeapAlloc(GetProcessHeap(), 0, (This->wineasio_number_inputs + This->wineasio_number_outputs) * sizeof(IOChannel));
if (!This->input_channel)
{
jack_client_close(This->jack_client);
jackbridge_client_close(This->jack_client);
ERR("Unable to allocate IOChannel structures for %i channels\n", This->wineasio_number_inputs);
return 0;
}
@@ -479,10 +479,10 @@ HIDDEN LONG STDMETHODCALLTYPE Init(LPWINEASIO iface, void *sysRef)
TRACE("%i IOChannel structures allocated\n", This->wineasio_number_inputs + This->wineasio_number_outputs);

/* Get and count physical JACK ports */
This->jack_input_ports = jack_get_ports(This->jack_client, NULL, NULL, JackPortIsPhysical | JackPortIsOutput);
This->jack_input_ports = jackbridge_get_ports(This->jack_client, NULL, NULL, JackPortIsPhysical | JackPortIsOutput);
for (This->jack_num_input_ports = 0; This->jack_input_ports && This->jack_input_ports[This->jack_num_input_ports]; This->jack_num_input_ports++)
;
This->jack_output_ports = jack_get_ports(This->jack_client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
This->jack_output_ports = jackbridge_get_ports(This->jack_client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
for (This->jack_num_output_ports = 0; This->jack_output_ports && This->jack_output_ports[This->jack_num_output_ports]; This->jack_num_output_ports++)
;

@@ -492,7 +492,7 @@ HIDDEN LONG STDMETHODCALLTYPE Init(LPWINEASIO iface, void *sysRef)
This->input_channel[i].active = false;
This->input_channel[i].port = NULL;
snprintf(This->input_channel[i].port_name, WINEASIO_MAX_NAME_LENGTH, "in_%i", i + 1);
This->input_channel[i].port = jack_port_register(This->jack_client,
This->input_channel[i].port = jackbridge_port_register(This->jack_client,
This->input_channel[i].port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, i);
/* TRACE("IOChannel structure initialized for input %d: '%s'\n", i, This->input_channel[i].port_name); */
}
@@ -501,41 +501,41 @@ HIDDEN LONG STDMETHODCALLTYPE Init(LPWINEASIO iface, void *sysRef)
This->output_channel[i].active = false;
This->output_channel[i].port = NULL;
snprintf(This->output_channel[i].port_name, WINEASIO_MAX_NAME_LENGTH, "out_%i", i + 1);
This->output_channel[i].port = jack_port_register(This->jack_client,
This->output_channel[i].port = jackbridge_port_register(This->jack_client,
This->output_channel[i].port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, i);
/* TRACE("IOChannel structure initialized for output %d: '%s'\n", i, This->output_channel[i].port_name); */
}
TRACE("%i IOChannel structures initialized\n", This->wineasio_number_inputs + This->wineasio_number_outputs);

jack_set_thread_creator(jack_thread_creator);
jackbridge_set_thread_creator(jack_thread_creator);

if (jack_set_buffer_size_callback(This->jack_client, jack_buffer_size_callback, This))
if (!jackbridge_set_buffer_size_callback(This->jack_client, jack_buffer_size_callback, This))
{
jack_client_close(This->jack_client);
jackbridge_client_close(This->jack_client);
HeapFree(GetProcessHeap(), 0, This->input_channel);
ERR("Unable to register JACK buffer size change callback\n");
return 0;
}
if (jack_set_latency_callback(This->jack_client, jack_latency_callback, This))
if (!jackbridge_set_latency_callback(This->jack_client, jack_latency_callback, This))
{
jack_client_close(This->jack_client);
jackbridge_client_close(This->jack_client);
HeapFree(GetProcessHeap(), 0, This->input_channel);
ERR("Unable to register JACK latency callback\n");
return 0;
}

if (jack_set_process_callback(This->jack_client, jack_process_callback, This))
if (!jackbridge_set_process_callback(This->jack_client, jack_process_callback, This))
{
jack_client_close(This->jack_client);
jackbridge_client_close(This->jack_client);
HeapFree(GetProcessHeap(), 0, This->input_channel);
ERR("Unable to register JACK process callback\n");
return 0;
}

if (jack_set_sample_rate_callback (This->jack_client, jack_sample_rate_callback, This))
if (!jackbridge_set_sample_rate_callback (This->jack_client, jack_sample_rate_callback, This))
{
jack_client_close(This->jack_client);
jackbridge_client_close(This->jack_client);
HeapFree(GetProcessHeap(), 0, This->input_channel);
ERR("Unable to register JACK sample rate change callback\n");
return 0;
@@ -708,9 +708,9 @@ HIDDEN LONG STDMETHODCALLTYPE GetLatencies(LPWINEASIO iface, LONG *inputLatency,
if (This->host_driver_state == Loaded)
return -1000;

jack_port_get_latency_range(This->input_channel[0].port, JackCaptureLatency, &range);
jackbridge_port_get_latency_range(This->input_channel[0].port, JackCaptureLatency, &range);
*inputLatency = range.max;
jack_port_get_latency_range(This->output_channel[0].port, JackPlaybackLatency, &range);
jackbridge_port_get_latency_range(This->output_channel[0].port, JackPlaybackLatency, &range);
*outputLatency = range.max;
TRACE("iface: %p, input latency: %d, output latency: %d\n", iface, *inputLatency, *outputLatency);

@@ -985,7 +985,7 @@ HIDDEN LONG STDMETHODCALLTYPE CreateBuffers(LPWINEASIO iface, BufferInformation
else
{
This->host_current_buffersize = bufferSize;
if (jack_set_buffer_size(This->jack_client, This->host_current_buffersize))
if (jackbridge_set_buffer_size(This->jack_client, This->host_current_buffersize))
{
WARN("JACK is unable to set buffersize to %i\n", (int)This->host_current_buffersize);
return -999;
@@ -1054,18 +1054,18 @@ HIDDEN LONG STDMETHODCALLTYPE CreateBuffers(LPWINEASIO iface, BufferInformation
}
TRACE("%i audio channels initialized\n", This->host_active_inputs + This->host_active_outputs);

if (jack_activate(This->jack_client))
if (!jackbridge_activate(This->jack_client))
return -1000;

/* connect to the hardware io */
if (This->wineasio_connect_to_hardware)
{
for (i = 0; i < This->jack_num_input_ports && i < This->wineasio_number_inputs; i++)
if (strstr(jack_port_type(jack_port_by_name(This->jack_client, This->jack_input_ports[i])), "audio"))
jack_connect(This->jack_client, This->jack_input_ports[i], jack_port_name(This->input_channel[i].port));
if (strstr(jackbridge_port_type(jackbridge_port_by_name(This->jack_client, This->jack_input_ports[i])), "audio"))
jackbridge_connect(This->jack_client, This->jack_input_ports[i], jackbridge_port_name(This->input_channel[i].port));
for (i = 0; i < This->jack_num_output_ports && i < This->wineasio_number_outputs; i++)
if (strstr(jack_port_type(jack_port_by_name(This->jack_client, This->jack_output_ports[i])), "audio"))
jack_connect(This->jack_client, jack_port_name(This->output_channel[i].port), This->jack_output_ports[i]);
if (strstr(jackbridge_port_type(jackbridge_port_by_name(This->jack_client, This->jack_output_ports[i])), "audio"))
jackbridge_connect(This->jack_client, jackbridge_port_name(This->output_channel[i].port), This->jack_output_ports[i]);
}

/* at this point all the connections are made and the jack process callback is outputting silence */
@@ -1094,7 +1094,7 @@ HIDDEN LONG STDMETHODCALLTYPE DisposeBuffers(LPWINEASIO iface)
if (This->host_driver_state != Prepared)
return -1000;

if (jack_deactivate(This->jack_client))
if (!jackbridge_deactivate(This->jack_client))
return -1000;

This->host_callbacks = NULL;
@@ -1280,7 +1280,8 @@ static inline int jack_process_callback(jack_nframes_t nframes, void *arg)
if (This->host_driver_state != Running)
{
for (i = 0; i < This->host_active_outputs; i++)
bzero(jack_port_get_buffer(This->output_channel[i].port, nframes), sizeof (jack_default_audio_sample_t) * nframes);
memset(jackbridge_port_get_buffer(This->output_channel[i].port, nframes),
0, sizeof (jack_default_audio_sample_t) * nframes);
return 0;
}

@@ -1288,7 +1289,7 @@ static inline int jack_process_callback(jack_nframes_t nframes, void *arg)
for (i = 0; i < This->wineasio_number_inputs; i++)
if (This->input_channel[i].active)
memcpy (&This->input_channel[i].audio_buffer[nframes * This->host_buffer_index],
jack_port_get_buffer(This->input_channel[i].port, nframes),
jackbridge_port_get_buffer(This->input_channel[i].port, nframes),
sizeof (jack_default_audio_sample_t) * nframes);

if (This->host_num_samples.lo > ULONG_MAX - nframes)
@@ -1310,7 +1311,7 @@ static inline int jack_process_callback(jack_nframes_t nframes, void *arg)

if (This->host_can_time_code) /* FIXME addionally use time code if supported */
{
jack_transport_state = jack_transport_query(This->jack_client, &jack_position);
jack_transport_state = jackbridge_transport_query(This->jack_client, &jack_position);
This->host_time.flagsForTimeCode = 0x1;
if (jack_transport_state == JackTransportRolling)
This->host_time.flagsForTimeCode |= 0x2;
@@ -1325,7 +1326,7 @@ static inline int jack_process_callback(jack_nframes_t nframes, void *arg)
/* copy host to jack buffers */
for (i = 0; i < This->wineasio_number_outputs; i++)
if (This->output_channel[i].active)
memcpy(jack_port_get_buffer(This->output_channel[i].port, nframes),
memcpy(jackbridge_port_get_buffer(This->output_channel[i].port, nframes),
&This->output_channel[i].audio_buffer[nframes * This->host_buffer_index],
sizeof (jack_default_audio_sample_t) * nframes);



+ 1214
- 0
jackbridge.c
File diff suppressed because it is too large
View File


+ 355
- 0
jackbridge.h View File

@@ -0,0 +1,355 @@
/*
* 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);

Write Preview
Loading…
Cancel
Save