falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Browse Source

Update jackbridge code from Carla, and clean it

tags/v0.9.0
falkTX 12 years ago
parent
b0472d09ef
commit
b004e8659d
6 changed files with 817 additions and 884 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -150
      c++/jackbridge/CarlaDefines.hpp
  2. +0
    -418
      c++/jackbridge/CarlaUtils.hpp
  3. +578
    -159
      c++/jackbridge/JackBridge.cpp
  4. +140
    -126
      c++/jackbridge/JackBridge.hpp
  5. +77
    -0
      c++/jackbridge/JackBridgeDefines.hpp
  6. +22
    -31
      c++/jackbridge/JackBridgeLibUtils.hpp

+ 0
- 150
c++/jackbridge/CarlaDefines.hpp View File

@@ -1,150 +0,0 @@
/*
* Carla common defines
* Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For a full copy of the GNU General Public License see the COPYING file
*/

#ifndef __CARLA_DEFINES_HPP__
#define __CARLA_DEFINES_HPP__

// Check OS
#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
# define CARLA_OS_WIN64
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
# define CARLA_OS_WIN32
#elif defined(__APPLE__)
# define CARLA_OS_MAC
#elif defined(__HAIKU__)
# define CARLA_OS_HAIKU
#elif defined(__linux__) || defined(__linux)
# define CARLA_OS_LINUX
#else
# warning Unsupported platform!
#endif

#if defined(CARLA_OS_WIN32) || defined(CARLA_OS_WIN64)
# define CARLA_OS_WIN
#elif ! defined(CARLA_OS_HAIKU)
# define CARLA_OS_UNIX
#endif

// Check for C++11 support
#if defined(HAVE_CPP11_SUPPORT)
# define CARLA_PROPER_CPP11_SUPPORT
#elif defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
# if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
# define CARLA_PROPER_CPP11_SUPPORT
# if (__GNUC__ * 100 + __GNUC_MINOR__) < 407
# define override // gcc4.7+ only
# endif
# endif
#endif

#ifndef CARLA_PROPER_CPP11_SUPPORT
# define override
# define noexcept
# define nullptr (0)
#endif

// Common includes
#ifdef CARLA_OS_WIN
# include <winsock2.h>
# include <windows.h>
#else
# include <unistd.h>
# ifndef __cdecl
# define __cdecl
# endif
#endif

// Define various string format types
#if defined(CARLA_OS_WIN64)
# define P_INT64 "%I64i"
# define P_INTPTR "%I64i"
# define P_UINTPTR "%I64x"
# define P_SIZE "%I64u"
#elif defined(CARLA_OS_WIN32)
# define P_INT64 "%I64i"
# define P_INTPTR "%i"
# define P_UINTPTR "%x"
# define P_SIZE "%u"
#elif __WORDSIZE == 64
# define P_INT64 "%li"
# define P_INTPTR "%li"
# define P_UINTPTR "%lx"
# define P_SIZE "%lu"
#else
# define P_INT64 "%lli"
# define P_INTPTR "%i"
# define P_UINTPTR "%x"
# define P_SIZE "%u"
#endif

// Define BINARY_NATIVE
#if defined(CARLA_OS_HAIKU) || defined(CARLA_OS_UNIX)
# if defined (__LP64__) || defined (_LP64)
# define BINARY_NATIVE BINARY_POSIX64
# else
# define BINARY_NATIVE BINARY_POSIX32
# endif
#elif defined(CARLA_OS_WIN)
# ifdef CARLA_OS_WIN64
# define BINARY_NATIVE BINARY_WIN64
# else
# define BINARY_NATIVE BINARY_WIN32
# endif
#else
# warning Unknown binary native
# define BINARY_NATIVE BINARY_OTHER
#endif

// Define CARLA_SAFE_ASSERT*
#define CARLA_SAFE_ASSERT(cond) ((!(cond)) ? carla_assert(#cond, __FILE__, __LINE__) : pass())
#define CARLA_SAFE_ASSERT_INT(cond, value) ((!(cond)) ? carla_assert_int(#cond, __FILE__, __LINE__, value) : pass())
#define CARLA_SAFE_ASSERT_INT2(cond, v1, v2) ((!(cond)) ? carla_assert_int2(#cond, __FILE__, __LINE__, v1, v2) : pass())

// Define CARLA_ASSERT*
#if defined(CARLA_NO_ASSERTS)
# define CARLA_ASSERT(cond)
# define CARLA_ASSERT_INT(cond, value)
# define CARLA_ASSERT_INT2(cond, v1, v2)
#elif defined(NDEBUG)
# define CARLA_ASSERT CARLA_SAFE_ASSERT
# define CARLA_ASSERT_INT CARLA_SAFE_ASSERT_INT
# define CARLA_ASSERT_INT2 CARLA_SAFE_ASSERT_INT2
#else
# define CARLA_ASSERT(cond) assert(cond)
# define CARLA_ASSERT_INT(cond, value) assert(cond)
# define CARLA_ASSERT_INT2(cond, v1, v2) assert(cond)
#endif

// Define CARLA_EXPORT
#ifdef BUILD_BRIDGE
# define CARLA_EXPORT extern "C"
#else
# if defined(CARLA_OS_WIN) && ! defined(__WINE__)
# define CARLA_EXPORT extern "C" __declspec (dllexport)
# else
# define CARLA_EXPORT extern "C" __attribute__ ((visibility("default")))
# endif
#endif

// Define OS_SEP
#ifdef CARLA_OS_WIN
# define OS_SEP '\\'
#else
# define OS_SEP '/'
#endif

#endif // __CARLA_DEFINES_HPP__

+ 0
- 418
c++/jackbridge/CarlaUtils.hpp View File

@@ -1,418 +0,0 @@
/*
* Carla common utils
* Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For a full copy of the GNU General Public License see the COPYING file
*/

#ifndef __CARLA_UTILS_HPP__
#define __CARLA_UTILS_HPP__

#include "CarlaDefines.hpp"

#include <cassert>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#ifdef CARLA_PROPER_CPP11_SUPPORT
# include <cstdint>
#else
# include <stdint.h>
#endif

#if defined(CARLA_OS_HAIKU)
# include <kernel/OS.h>
#elif defined(CARLA_OS_LINUX)
# include <sys/prctl.h>
# include <linux/prctl.h>
#endif

// -------------------------------------------------
// misc functions

static inline
const char* bool2str(const bool yesNo)
{
return yesNo ? "true" : "false";
}

static inline
void pass() {}

// -------------------------------------------------
// string print functions

#ifndef DEBUG
# define carla_debug(...)
#else
static inline
void carla_debug(const char* const fmt, ...)
{
va_list args;
va_start(args, fmt);
# ifndef CARLA_OS_WIN
std::fprintf(stdout, "\x1b[30;1m");
# endif
std::vfprintf(stdout, fmt, args);
# ifndef CARLA_OS_WIN
std::fprintf(stdout, "\x1b[0m\n");
# else
std::fprintf(stdout, "\n");
# endif
va_end(args);
}
#endif

static inline
void carla_stdout(const char* const fmt, ...)
{
va_list args;
va_start(args, fmt);
std::vfprintf(stdout, fmt, args);
std::fprintf(stdout, "\n");
va_end(args);
}

static inline
void carla_stderr(const char* const fmt, ...)
{
va_list args;
va_start(args, fmt);
std::vfprintf(stderr, fmt, args);
std::fprintf(stderr, "\n");
va_end(args);
}

static inline
void carla_stderr2(const char* const fmt, ...)
{
va_list args;
va_start(args, fmt);
#ifndef CARLA_OS_WIN
std::fprintf(stderr, "\x1b[31m");
#endif
std::vfprintf(stderr, fmt, args);
#ifndef CARLA_OS_WIN
std::fprintf(stderr, "\x1b[0m\n");
#else
std::fprintf(stderr, "\n");
#endif
va_end(args);
}

// -------------------------------------------------
// carla_assert*

static inline
void carla_assert(const char* const assertion, const char* const file, const int line)
{
carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i", assertion, file, line);
}

static inline
void carla_assert_int(const char* const assertion, const char* const file, const int line, const int value)
{
carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i, value %i", assertion, file, line, value);
}

static inline
void carla_assert_int2(const char* const assertion, const char* const file, const int line, const int v1, const int v2)
{
carla_stderr2("Carla assertion failure: \"%s\" in file %s, line %i, v1 %i, v2 %i", assertion, file, line, v1, v2);
}

// -------------------------------------------------
// carla_*sleep

static inline
void carla_sleep(const unsigned int secs)
{
CARLA_ASSERT(secs > 0);

#ifdef CARLA_OS_WIN
Sleep(secs * 1000);
#else
sleep(secs);
#endif
}

static inline
void carla_msleep(const unsigned int msecs)
{
CARLA_ASSERT(msecs > 0);

#ifdef CARLA_OS_WIN
Sleep(msecs);
#else
usleep(msecs * 1000);
#endif
}

// -------------------------------------------------
// carla_setenv

static inline
void carla_setenv(const char* const key, const char* const value)
{
CARLA_ASSERT(key != nullptr);
CARLA_ASSERT(value != nullptr);

#ifdef CARLA_OS_WIN
SetEnvironmentVariableA(key, value);
#else
setenv(key, value, 1);
#endif
}

// -------------------------------------------------
// carla_setprocname (not available on all platforms)

static inline
void carla_setprocname(const char* const name)
{
CARLA_ASSERT(name != nullptr);

#if defined(CARLA_OS_HAIKU)
if ((thread_id this_thread = find_thread(nullptr)) != B_NAME_NOT_FOUND)
rename_thread(this_thread, name);
#elif defined(CARLA_OS_LINUX)
prctl(PR_SET_NAME, name);
#else
carla_stderr("carla_setprocname(\"%s\") - unsupported on this platform", name);
#endif
}

// -------------------------------------------------
// carla_strdup

static inline
const char* carla_strdup(const char* const strBuf)
{
CARLA_ASSERT(strBuf != nullptr);

const size_t bufferLen = (strBuf != nullptr) ? std::strlen(strBuf) : 0;
char* const buffer = new char[bufferLen+1];

if (strBuf != nullptr && bufferLen > 0)
std::strcpy(buffer, strBuf);

buffer[bufferLen] = '\0';

return buffer;
}

static inline
const char* carla_strdup_free(char* const strBuf)
{
const char* const buffer = carla_strdup(strBuf);
std::free(strBuf);
return buffer;
}

// -------------------------------------------------
// math functions

template<typename T>
static inline
const T& carla_min(const T& v1, const T& v2, const T& min)
{
return ((v1 < min || v2 < min) ? min : (v1 < v2 ? v1 : v2));
}

template<typename T>
static inline
const T& carla_max(const T& v1, const T& v2, const T& max)
{
return ((v1 > max || v2 > max) ? max : (v1 > v2 ? v1 : v2));
}

template<typename T>
static inline
const T& carla_fixValue(const T& min, const T& max, const T& value)
{
if (value < min)
return min;
if (value > max)
return max;
return value;
}

template<typename T>
static inline
void carla_add(T* dataDst, T* dataSrc, const size_t size)
{
CARLA_ASSERT(dataDst != nullptr);
CARLA_ASSERT(dataSrc != nullptr);
CARLA_ASSERT(size != 0);

if (dataDst == nullptr || dataSrc == nullptr || size == 0)
return;

for (size_t i=0; i < size; ++i)
*dataDst++ += *dataSrc++;
}

template<typename T>
static inline
void carla_add(T* dataDst, const T* dataSrc, const size_t size)
{
CARLA_ASSERT(dataDst != nullptr);
CARLA_ASSERT(dataSrc != nullptr);
CARLA_ASSERT(size != 0);

if (dataDst == nullptr || dataSrc == nullptr || size == 0)
return;

for (size_t i=0; i < size; ++i)
*dataDst++ += *dataSrc++;
}

template<typename T>
static inline
void carla_copy(T* dataDst, T* dataSrc, const size_t size)
{
CARLA_ASSERT(dataDst != nullptr);
CARLA_ASSERT(dataSrc != nullptr);
CARLA_ASSERT(size != 0);

if (dataDst == nullptr || dataSrc == nullptr || size == 0)
return;

for (size_t i=0; i < size; ++i)
*dataDst++ = *dataSrc++;
}

template<typename T>
static inline
void carla_copy(T* dataDst, const T* dataSrc, const size_t size)
{
CARLA_ASSERT(dataDst != nullptr);
CARLA_ASSERT(dataSrc != nullptr);
CARLA_ASSERT(size != 0);

if (dataDst == nullptr || dataSrc == nullptr || size == 0)
return;

for (size_t i=0; i < size; ++i)
*dataDst++ = *dataSrc++;
}

template<typename T>
static inline
void carla_fill(T* data, const size_t size, const T v)
{
CARLA_ASSERT(data != nullptr);
CARLA_ASSERT(size != 0);

if (data == nullptr || size == 0)
return;

for (size_t i=0; i < size; ++i)
*data++ = v;
}

static inline
void carla_addDouble(double* const dataDst, double* const dataSrc, const size_t size)
{
carla_add<double>(dataDst, dataSrc, size);
}

static inline
void carla_addFloat(float* const dataDst, float* const dataSrc, const size_t size)
{
carla_add<float>(dataDst, dataSrc, size);
}

static inline
void carla_copyDouble(double* const dataDst, double* const dataSrc, const size_t size)
{
CARLA_ASSERT(dataDst != nullptr);
CARLA_ASSERT(dataSrc != nullptr);
CARLA_ASSERT(size > 0);

std::memcpy(dataDst, dataSrc, size*sizeof(double));
}

static inline
void carla_copyFloat(float* const dataDst, float* const dataSrc, const size_t size)
{
CARLA_ASSERT(dataDst != nullptr);
CARLA_ASSERT(dataSrc != nullptr);
CARLA_ASSERT(size > 0);

std::memcpy(dataDst, dataSrc, size*sizeof(float));
}

static inline
void carla_zeroDouble(double* const data, const size_t size)
{
carla_fill<double>(data, size, 0.0);
}

static inline
void carla_zeroFloat(float* const data, const size_t size)
{
carla_fill<float>(data, size, 0.0f);
}

#if defined(CARLA_OS_MAC) && ! defined(DISTRHO_OS_MAC)
namespace std {
inline float
fmin(float __x, float __y)
{ return __builtin_fminf(__x, __y); }
inline float
fmax(float __x, float __y)
{ return __builtin_fmaxf(__x, __y); }
inline float
rint(float __x)
{ return __builtin_rintf(__x); }
}
#endif

// -------------------------------------------------
// memory functions

static inline
void carla_zeroMem(void* const memory, const size_t numBytes)
{
CARLA_ASSERT(memory != nullptr);
CARLA_ASSERT(numBytes != 0);

if (memory == nullptr || numBytes == 0)
return;

std::memset(memory, 0, numBytes);
}

template <typename T>
static inline
void carla_zeroStruct(T& structure)
{
std::memset(&structure, 0, sizeof(T));
}

template <typename T>
static inline
void carla_zeroStruct(T* const structure, const size_t count)
{
CARLA_ASSERT(structure != nullptr);
CARLA_ASSERT(count >= 1);

std::memset(structure, 0, sizeof(T)*count);
}

// -------------------------------------------------

#endif // __CARLA_UTILS_HPP__

+ 578
- 159
c++/jackbridge/JackBridge.cpp
File diff suppressed because it is too large
View File


+ 140
- 126
c++/jackbridge/JackBridge.hpp View File

@@ -2,28 +2,22 @@
* JackBridge * JackBridge
* Copyright (C) 2013 Filipe Coelho <falktx@falktx.com> * Copyright (C) 2013 Filipe Coelho <falktx@falktx.com>
* *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
* 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.
* *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For a full copy of the GNU General Public License see the COPYING file
* 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.
*/ */


#ifndef __JACKBRIDGE_HPP__
#define __JACKBRIDGE_HPP__

#include "CarlaDefines.hpp"
#ifndef JACKBRIDGE_HPP_INCLUDED
#define JACKBRIDGE_HPP_INCLUDED


#ifndef JACKBRIDGE_EXPORT
# undef CARLA_EXPORT
# define CARLA_EXPORT
#endif
#include "JackBridgeDefines.hpp"


#ifdef JACKBRIDGE_DIRECT #ifdef JACKBRIDGE_DIRECT
# include <jack/jack.h> # include <jack/jack.h>
@@ -34,7 +28,7 @@


#include <cstddef> #include <cstddef>


#ifdef CARLA_PROPER_CPP11_SUPPORT
#ifdef JACKBRIDGE_PROPER_CPP11_SUPPORT
# include <cstdint> # include <cstdint>
#else #else
# include <stdint.h> # include <stdint.h>
@@ -94,18 +88,18 @@ enum JackOptions {
}; };


enum JackStatus { enum JackStatus {
JackFailure = 0x01,
JackInvalidOption = 0x02,
JackNameNotUnique = 0x04,
JackServerStarted = 0x08,
JackServerFailed = 0x10,
JackServerError = 0x20,
JackNoSuchClient = 0x40,
JackLoadFailure = 0x80,
JackInitFailure = 0x100,
JackShmFailure = 0x200,
JackVersionError = 0x400,
JackBackendError = 0x800,
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 JackClientZombie = 0x1000
}; };


@@ -115,10 +109,10 @@ enum JackLatencyCallbackMode {
}; };


enum JackPortFlags { enum JackPortFlags {
JackPortIsInput = 0x1,
JackPortIsOutput = 0x2,
JackPortIsPhysical = 0x4,
JackPortCanMonitor = 0x8,
JackPortIsInput = 0x01,
JackPortIsOutput = 0x02,
JackPortIsPhysical = 0x04,
JackPortCanMonitor = 0x08,
JackPortIsTerminal = 0x10, JackPortIsTerminal = 0x10,
JackPortIsControlVoltage = 0x100 JackPortIsControlVoltage = 0x100
}; };
@@ -146,8 +140,8 @@ enum JackSessionEventType {
}; };


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


enum JackCustomChange { enum JackCustomChange {
@@ -234,8 +228,8 @@ typedef struct _jack_session_command_t jack_session_command_t;


typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg); typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);
typedef int (*JackProcessCallback)(jack_nframes_t nframes, void* arg); typedef int (*JackProcessCallback)(jack_nframes_t nframes, void* arg);
typedef void (*JackThreadInitCallback)(void *arg);
typedef int (*JackGraphOrderCallback)(void *arg);
typedef void (*JackThreadInitCallback)(void* arg);
typedef int (*JackGraphOrderCallback)(void* arg);
typedef int (*JackXRunCallback)(void* arg); typedef int (*JackXRunCallback)(void* arg);
typedef int (*JackBufferSizeCallback)(jack_nframes_t nframes, void* arg); typedef int (*JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);
typedef int (*JackSampleRateCallback)(jack_nframes_t nframes, void* arg); typedef int (*JackSampleRateCallback)(jack_nframes_t nframes, void* arg);
@@ -254,90 +248,110 @@ typedef void (*JackCustomDataAppearanceCallback)(const char* client_name, const


#endif // ! JACKBRIDGE_DIRECT #endif // ! JACKBRIDGE_DIRECT


CARLA_EXPORT const char* jackbridge_get_version_string();
CARLA_EXPORT jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...);
CARLA_EXPORT const char* jackbridge_client_rename(jack_client_t* client, const char* new_name);

CARLA_EXPORT bool jackbridge_client_close(jack_client_t* client);
CARLA_EXPORT int jackbridge_client_name_size();
CARLA_EXPORT char* jackbridge_get_client_name(jack_client_t* client);

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

CARLA_EXPORT int jackbridge_get_client_pid(const char* name);
CARLA_EXPORT int jackbridge_is_realtime(jack_client_t* client);

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

CARLA_EXPORT bool jackbridge_set_freewheel(jack_client_t* client, int onoff);
CARLA_EXPORT bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);
CARLA_EXPORT bool jackbridge_engine_takeover_timebase(jack_client_t* client);
CARLA_EXPORT float jackbridge_cpu_load(jack_client_t* client);

CARLA_EXPORT jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);
CARLA_EXPORT jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);

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);

CARLA_EXPORT bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);
CARLA_EXPORT void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);

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

CARLA_EXPORT bool jackbridge_port_set_name(jack_port_t* port, const char* port_name);
CARLA_EXPORT bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);
CARLA_EXPORT bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);
CARLA_EXPORT int jackbridge_port_name_size();
CARLA_EXPORT void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);
CARLA_EXPORT void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);
CARLA_EXPORT bool jackbridge_recompute_total_latencies(jack_client_t* client);

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

CARLA_EXPORT void jackbridge_free(void* ptr);

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

CARLA_EXPORT int jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);
CARLA_EXPORT void jackbridge_transport_start(jack_client_t* client);
CARLA_EXPORT void jackbridge_transport_stop(jack_client_t* client);
CARLA_EXPORT jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);

CARLA_EXPORT bool jackbridge_custom_publish_data(jack_client_t* client, const char* key, const void* data, size_t size);
CARLA_EXPORT bool jackbridge_custom_get_data(jack_client_t* client, const char* client_name, const char* key, void** data, size_t* size);
CARLA_EXPORT bool jackbridge_custom_unpublish_data(jack_client_t* client, const char* key);
CARLA_EXPORT bool jackbridge_custom_set_data_appearance_callback(jack_client_t* client, JackCustomDataAppearanceCallback callback, void* arg);
CARLA_EXPORT const char** jackbridge_custom_get_keys(jack_client_t* client, const char* client_name);

#endif // __JACKBRIDGE_HPP__
JACKBRIDGE_EXPORT void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);
JACKBRIDGE_EXPORT const char* jackbridge_get_version_string();

JACKBRIDGE_EXPORT jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...);
JACKBRIDGE_EXPORT const char* jackbridge_client_rename(jack_client_t* client, const char* new_name);
JACKBRIDGE_EXPORT bool jackbridge_client_close(jack_client_t* client);

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

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

JACKBRIDGE_EXPORT int jackbridge_get_client_pid(const char* name);
JACKBRIDGE_EXPORT bool jackbridge_is_realtime(jack_client_t* client);

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

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

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

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

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

JACKBRIDGE_EXPORT bool jackbridge_port_set_name(jack_port_t* port, const char* port_name);
JACKBRIDGE_EXPORT bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);
JACKBRIDGE_EXPORT bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);
JACKBRIDGE_EXPORT int jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2]);

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

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

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

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

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

JACKBRIDGE_EXPORT void jackbridge_free(void* ptr);

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

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

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

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

JACKBRIDGE_EXPORT bool jackbridge_custom_publish_data(jack_client_t* client, const char* key, const void* data, size_t size);
JACKBRIDGE_EXPORT bool jackbridge_custom_get_data(jack_client_t* client, const char* client_name, const char* key, void** data, size_t* size);
JACKBRIDGE_EXPORT bool jackbridge_custom_unpublish_data(jack_client_t* client, const char* key);
JACKBRIDGE_EXPORT bool jackbridge_custom_set_data_appearance_callback(jack_client_t* client, JackCustomDataAppearanceCallback callback, void* arg);
JACKBRIDGE_EXPORT const char** jackbridge_custom_get_keys(jack_client_t* client, const char* client_name);

#endif // JACKBRIDGE_HPP_INCLUDED

+ 77
- 0
c++/jackbridge/JackBridgeDefines.hpp View File

@@ -0,0 +1,77 @@
/*
* JackBridge common defines
* Copyright (C) 2013 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.
*/

#ifndef JACKBRIDGE_DEFINES_HPP_INCLUDED
#define JACKBRIDGE_DEFINES_HPP_INCLUDED

// Check OS
#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
# define JACKBRIDGE_OS_WIN64
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
# define JACKBRIDGE_OS_WIN32
#elif defined(__APPLE__)
# define JACKBRIDGE_OS_MAC
#elif defined(__HAIKU__)
# define JACKBRIDGE_OS_HAIKU
#elif defined(__linux__) || defined(__linux)
# define JACKBRIDGE_OS_LINUX
#else
# warning Unsupported platform!
#endif

#if defined(JACKBRIDGE_OS_WIN32) || defined(JACKBRIDGE_OS_WIN64)
# define JACKBRIDGE_OS_WIN
#elif ! defined(JACKBRIDGE_OS_HAIKU)
# define JACKBRIDGE_OS_UNIX
#endif

// Check for C++11 support
#if defined(HAVE_CPP11_SUPPORT)
# define JACKBRIDGE_PROPER_CPP11_SUPPORT
#elif defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
# if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
# define JACKBRIDGE_PROPER_CPP11_SUPPORT
# if (__GNUC__ * 100 + __GNUC_MINOR__) < 407
# define override // gcc4.7+ only
# endif
# endif
#endif

#ifndef JACKBRIDGE_PROPER_CPP11_SUPPORT
# define override
# define noexcept
# define nullptr (0)
#endif

// Common includes
#ifdef JACKBRIDGE_OS_WIN
# include <winsock2.h>
# include <windows.h>
#else
# include <unistd.h>
# ifndef __cdecl
# define __cdecl
# endif
#endif

// Define JACKBRIDGE_EXPORT
#if defined(JACKBRIDGE_OS_WIN) && ! defined(__WINE__)
# define JACKBRIDGE_EXPORT extern "C" __declspec (dllexport)
#else
# define JACKBRIDGE_EXPORT extern "C" __attribute__ ((visibility("default")))
#endif

#endif // JACKBRIDGE_DEFINES_HPP_INCLUDED

c++/jackbridge/CarlaLibUtils.hpp → c++/jackbridge/JackBridgeLibUtils.hpp View File

@@ -1,26 +1,27 @@
/* /*
* Carla library utils
* Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
* JackBridge library utils
* Copyright (C) 2013 Filipe Coelho <falktx@falktx.com>
* *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
* 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.
* *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For a full copy of the GNU General Public License see the COPYING file
* 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.
*/ */


#ifndef __CARLA_LIB_UTILS_HPP__
#define __CARLA_LIB_UTILS_HPP__
#ifndef JACKBRIDGE_LIB_UTILS_HPP_INCLUDED
#define JACKBRIDGE_LIB_UTILS_HPP_INCLUDED

#include "JackBridgeDefines.hpp"


#include "CarlaUtils.hpp"
#include <cstdio>


#ifndef CARLA_OS_WIN
#ifndef JACKBRIDGE_OS_WIN
# include <dlfcn.h> # include <dlfcn.h>
#endif #endif


@@ -30,9 +31,7 @@
static inline static inline
void* lib_open(const char* const filename) void* lib_open(const char* const filename)
{ {
CARLA_ASSERT(filename != nullptr);

#ifdef CARLA_OS_WIN
#ifdef JACKBRIDGE_OS_WIN
return (void*)LoadLibraryA(filename); return (void*)LoadLibraryA(filename);
#else #else
return dlopen(filename, RTLD_NOW|RTLD_LOCAL); return dlopen(filename, RTLD_NOW|RTLD_LOCAL);
@@ -42,12 +41,10 @@ void* lib_open(const char* const filename)
static inline static inline
bool lib_close(void* const lib) bool lib_close(void* const lib)
{ {
CARLA_ASSERT(lib != nullptr);

if (lib == nullptr) if (lib == nullptr)
return false; return false;


#ifdef CARLA_OS_WIN
#ifdef JACKBRIDGE_OS_WIN
return FreeLibrary((HMODULE)lib); return FreeLibrary((HMODULE)lib);
#else #else
return (dlclose(lib) == 0); return (dlclose(lib) == 0);
@@ -57,13 +54,10 @@ bool lib_close(void* const lib)
static inline static inline
void* lib_symbol(void* const lib, const char* const symbol) void* lib_symbol(void* const lib, const char* const symbol)
{ {
CARLA_ASSERT(lib != nullptr);
CARLA_ASSERT(symbol != nullptr);

if (lib == nullptr && symbol == nullptr) if (lib == nullptr && symbol == nullptr)
return nullptr; return nullptr;


#ifdef CARLA_OS_WIN
#ifdef JACKBRIDGE_OS_WIN
return (void*)GetProcAddress((HMODULE)lib, symbol); return (void*)GetProcAddress((HMODULE)lib, symbol);
#else #else
return dlsym(lib, symbol); return dlsym(lib, symbol);
@@ -73,11 +67,8 @@ void* lib_symbol(void* const lib, const char* const symbol)
static inline static inline
const char* lib_error(const char* const filename) const char* lib_error(const char* const filename)
{ {
CARLA_ASSERT(filename != nullptr);

#ifdef CARLA_OS_WIN
#ifdef JACKBRIDGE_OS_WIN
static char libError[2048]; static char libError[2048];
//carla_fill<char>(libError, 2048, '\0');


LPVOID winErrorString; LPVOID winErrorString;
DWORD winErrorCode = GetLastError(); DWORD winErrorCode = GetLastError();
@@ -97,4 +88,4 @@ const char* lib_error(const char* const filename)


// ------------------------------------------------- // -------------------------------------------------


#endif // __CARLA_LIB_UTILS_HPP__
#endif // JACKBRIDGE_LIB_UTILS_HPP_INCLUDED

Write Preview
Loading…
Cancel
Save