Browse Source

Import and use jackbridge from Carla in C++ code

tags/v0.9.0
falkTX 10 years ago
parent
commit
a552c190eb
15 changed files with 2221 additions and 83 deletions
  1. +0
    -2
      c++/Makefile.mk
  2. +5
    -11
      c++/jack_utils.hpp
  3. +150
    -0
      c++/jackbridge/CarlaDefines.hpp
  4. +100
    -0
      c++/jackbridge/CarlaLibUtils.hpp
  5. +418
    -0
      c++/jackbridge/CarlaUtils.hpp
  6. +1092
    -0
      c++/jackbridge/JackBridge.cpp
  7. +343
    -0
      c++/jackbridge/JackBridge.hpp
  8. +67
    -0
      c++/jackbridge/Makefile
  9. +1
    -1
      c++/jackmeter/Makefile
  10. +27
    -27
      c++/jackmeter/jackmeter.cpp
  11. +1
    -1
      c++/xycontroller/Makefile
  12. +17
    -17
      c++/xycontroller/xycontroller.cpp
  13. +0
    -7
      data/windows/build-win32.sh
  14. +0
    -7
      data/windows/build-win64.sh
  15. +0
    -10
      data/windows/jack.pc

+ 0
- 2
c++/Makefile.mk View File

@@ -36,7 +36,5 @@ endif

# --------------------------------------------------------------

HAVE_QT5 = $(shell pkg-config --atleast-version 5 QtCore && echo true)

# Currently broken
# HAVE_JACKSESSION = $(shell pkg-config --atleast-version=0.121.0 jack && echo true)

+ 5
- 11
c++/jack_utils.hpp View File

@@ -18,37 +18,31 @@
#ifndef __JACK_UTILS_HPP__
#define __JACK_UTILS_HPP__

#include <jack/jack.h>
#include <jack/midiport.h>
#include <jack/transport.h>

#ifdef HAVE_JACKSESSION
# include <jack/session.h>
#endif
#include "jackbridge/JackBridge.cpp"

#include <cstring>
#include <string>
#include <vector>

static inline
std::vector<char*> jack_port_get_all_connections_as_vector(jack_client_t* const client, jack_port_t* const port)
std::vector<char*> jackbridge_port_get_all_connections_as_vector(jack_client_t* const client, jack_port_t* const port)
{
std::vector<char*> connectionsVector;
const char** connections = jack_port_get_all_connections(client, port);
const char** connections = jackbridge_port_get_all_connections(client, port);

if (connections)
{
for (int i=0; connections[i]; i++)
connectionsVector.push_back(strdup(connections[i]));

jack_free(connections);
jackbridge_free(connections);
}

return connectionsVector;
}

static inline
std::string jack_status_get_error_string(const jack_status_t& status)
std::string jackbridge_status_get_error_string(const jack_status_t& status)
{
std::string errorString;



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

@@ -0,0 +1,150 @@
/*
* 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__

+ 100
- 0
c++/jackbridge/CarlaLibUtils.hpp View File

@@ -0,0 +1,100 @@
/*
* Carla library 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_LIB_UTILS_HPP__
#define __CARLA_LIB_UTILS_HPP__

#include "CarlaUtils.hpp"

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

// -------------------------------------------------
// library related calls

static inline
void* lib_open(const char* const filename)
{
CARLA_ASSERT(filename != nullptr);

#ifdef CARLA_OS_WIN
return (void*)LoadLibraryA(filename);
#else
return dlopen(filename, RTLD_NOW|RTLD_LOCAL);
#endif
}

static inline
bool lib_close(void* const lib)
{
CARLA_ASSERT(lib != nullptr);

if (lib == nullptr)
return false;

#ifdef CARLA_OS_WIN
return FreeLibrary((HMODULE)lib);
#else
return (dlclose(lib) == 0);
#endif
}

static inline
void* lib_symbol(void* const lib, const char* const symbol)
{
CARLA_ASSERT(lib != nullptr);
CARLA_ASSERT(symbol != nullptr);

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

#ifdef CARLA_OS_WIN
return (void*)GetProcAddress((HMODULE)lib, symbol);
#else
return dlsym(lib, symbol);
#endif
}

static inline
const char* lib_error(const char* const filename)
{
CARLA_ASSERT(filename != nullptr);

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

LPVOID winErrorString;
DWORD winErrorCode = GetLastError();
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, winErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&winErrorString, 0, nullptr);

std::snprintf(libError, 2048, "%s: error code %li: %s", filename, winErrorCode, (const char*)winErrorString);
LocalFree(winErrorString);

return libError;
#else
return dlerror();

// unused
(void)filename;
#endif
}

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

#endif // __CARLA_LIB_UTILS_HPP__

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

@@ -0,0 +1,418 @@
/*
* 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__

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


+ 343
- 0
c++/jackbridge/JackBridge.hpp View File

@@ -0,0 +1,343 @@
/*
* JackBridge
* 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.
*
* 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 __JACKBRIDGE_HPP__
#define __JACKBRIDGE_HPP__

#include "CarlaDefines.hpp"

#ifndef JACKBRIDGE_EXPORT
# undef CARLA_EXPORT
# define CARLA_EXPORT
#endif

#ifdef JACKBRIDGE_DIRECT
# include <jack/jack.h>
# include <jack/midiport.h>
# include <jack/transport.h>
# include <jack/custom.h>
#else

#include <cstddef>

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

#ifndef POST_PACKED_STRUCTURE
# ifdef __GNUC__
/* POST_PACKED_STRUCTURE needs to be a macro which
expands into a compiler directive. The directive must
tell the compiler to arrange the preceding structure
declaration so that it is packed on byte-boundaries rather
than use the natural alignment of the processor and/or
compiler.
*/
#define PRE_PACKED_STRUCTURE
#define POST_PACKED_STRUCTURE __attribute__((__packed__))
# else
#ifdef _MSC_VER
#define PRE_PACKED_STRUCTURE1 __pragma(pack(push,1))
#define PRE_PACKED_STRUCTURE PRE_PACKED_STRUCTURE1
/* PRE_PACKED_STRUCTURE needs to be a macro which
expands into a compiler directive. The directive must
tell the compiler to arrange the following structure
declaration so that it is packed on byte-boundaries rather
than use the natural alignment of the processor and/or
compiler.
*/
#define POST_PACKED_STRUCTURE ;__pragma(pack(pop))
/* and POST_PACKED_STRUCTURE needs to be a macro which
restores the packing to its previous setting */
#else
#define PRE_PACKED_STRUCTURE
#define POST_PACKED_STRUCTURE
#endif // _MSC_VER
# endif // __GNUC__
#endif

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

#define JACK_HAS_CUSTOM_DATA_API 1
#define JACK_HAS_PORT_IS_CONTROL_VOLTAGE_FLAG 1

#define JackOpenOptions (JackSessionID|JackServerName|JackNoStartServer|JackUseExactName)
#define JackLoadOptions (JackLoadInit|JackLoadName|JackUseExactName)
#define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode)
#define EXTENDED_TIME_INFO

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

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,
JackClientZombie = 0x1000
};

enum JackLatencyCallbackMode {
JackCaptureLatency,
JackPlaybackLatency
};

enum JackPortFlags {
JackPortIsInput = 0x1,
JackPortIsOutput = 0x2,
JackPortIsPhysical = 0x4,
JackPortCanMonitor = 0x8,
JackPortIsTerminal = 0x10,
JackPortIsControlVoltage = 0x100
};

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

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

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

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

enum JackCustomChange {
JackCustomRemoved,
JackCustomAdded,
JackCustomReplaced
};

typedef uint32_t jack_nframes_t;
typedef uint32_t jack_port_id_t;
typedef uint64_t jack_time_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 JackCustomChange jack_custom_change_t;

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

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;
int32_t padding[7];
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 _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 int (*JackClientRenameCallback)(const char* old_name, const char* new_name, void* arg);
typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
typedef int (*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 (*JackCustomDataAppearanceCallback)(const char* client_name, const char* key, jack_custom_change_t change, void* arg);

#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__

+ 67
- 0
c++/jackbridge/Makefile View File

@@ -0,0 +1,67 @@
#!/usr/bin/make -f
# Makefile for jackbridge #
# ------------------------------------- #
# Created by falkTX
#

include ../../Makefile.mk

# --------------------------------------------------------------

WINECXX ?= wineg++

BUILD_CXX_FLAGS += -DJACKBRIDGE_EXPORT
BUILD_CXX_FLAGS += -I. -I../../includes -I../../utils

ifeq ($(MACOS),true)
LINK_FLAGS += -dynamiclib
else
LINK_FLAGS += -shared
endif

WIN_BUILD_FLAGS = $(BUILD_CXX_FLAGS) -DJACKBRIDGE_DUMMY=1 -w
WIN_32BIT_FLAGS = $(32BIT_FLAGS)
WIN_64BIT_FLAGS = $(64BIT_FLAGS)
WIN_LINK_FLAGS = $(LINK_FLAGS)

WINE_BUILD_FLAGS = $(BUILD_CXX_FLAGS) -fPIC
WINE_32BIT_FLAGS = $(32BIT_FLAGS) -L/usr/lib32/wine -L/usr/lib/i386-linux-gnu/wine
WINE_64BIT_FLAGS = $(64BIT_FLAGS) -L/usr/lib64/wine -L/usr/lib/x86_64-linux-gnu/wine
WINE_LINK_FLAGS = $(LINK_FLAGS) -ldl -lrt -lpthread

OBJS = JackBridge1.cpp JackBridge2.cpp
OBJSw32 = JackBridge1.w32.o JackBridge2.w32.o
OBJSw64 = JackBridge1.w64.o JackBridge2.w64.o

# --------------------------------------------------------------

all:

win32: ../jackbridge-win32.dll
win64: ../jackbridge-win64.dll
wine32: ../jackbridge-win32.dll.so
wine64: ../jackbridge-win64.dll.so

# --------------------------------------------------------------

JackBridge%.w32.o: JackBridge%.cpp
$(CXX) $^ $(WINE_BUILD_FLAGS) $(WINE_32BIT_FLAGS) -c -o $@

JackBridge%.w64.o: JackBridge%.cpp
$(CXX) $^ $(WINE_BUILD_FLAGS) $(WINE_64BIT_FLAGS) -c -o $@

# --------------------------------------------------------------

../jackbridge-win32.dll: $(OBJS)
$(CXX) $^ $(WIN_BUILD_FLAGS) $(WIN_32BIT_FLAGS) $(WIN_LINK_FLAGS) -Wl,--output-def,$@.def,--out-implib,$@.a -o $@ $(CMD_STRIP) $@

../jackbridge-win64.dll: $(OBJS)
$(CXX) $^ $(WIN_BUILD_FLAGS) $(WIN_64BIT_FLAGS) $(WIN_LINK_FLAGS) -Wl,--output-def,$@.def,--out-implib,$@.a -o $@ $(CMD_STRIP) $@

../jackbridge-win32.dll.so: $(OBJSw32) ../jackbridge-win32.dll.def
$(WINECXX) $^ $(WINE_32BIT_FLAGS) $(WINE_LINK_FLAGS) -o $@ $(CMD_STRIP) $@

../jackbridge-win64.dll.so: $(OBJS) ../jackbridge-win64.dll.def
$(WINECXX) $^ $(WINE_64BIT_FLAGS) $(WINE_LINK_FLAGS) -o $@ $(CMD_STRIP) $@

# --------------------------------------------------------------

+ 1
- 1
c++/jackmeter/Makefile View File

@@ -31,7 +31,7 @@ OBJS = \
all: cadence-jackmeter

cadence-jackmeter: $(FILES) $(OBJS)
$(CXX) $(OBJS) $(LINK_FLAGS) -o $@ && $(STRIP) $@
$(CXX) $(OBJS) $(LINK_FLAGS) -ldl -o $@ && $(STRIP) $@

cadence-jackmeter.exe: $(FILES) $(OBJS) icon.o
$(CXX) $(OBJS) icon.o $(LINK_FLAGS) -limm32 -lole32 -luuid -lwinspool -lws2_32 -mwindows -o $@ && $(STRIP) $@


+ 27
- 27
c++/jackmeter/jackmeter.cpp View File

@@ -49,8 +49,8 @@ bool gIsOutput = true;

int process_callback(const jack_nframes_t nframes, void*)
{
float* const jOut1 = (float*)jack_port_get_buffer(jPort1, nframes);
float* const jOut2 = (float*)jack_port_get_buffer(jPort2, nframes);
float* const jOut1 = (float*)jackbridge_port_get_buffer(jPort1, nframes);
float* const jOut2 = (float*)jackbridge_port_get_buffer(jPort2, nframes);

for (jack_nframes_t i = 0; i < nframes; i++)
{
@@ -81,12 +81,12 @@ void session_callback(jack_session_event_t* const event, void* const arg)

event->command_line = strdup(filepath.toUtf8().constData());

jack_session_reply(jClient, event);
jackbridge_session_reply(jClient, event);

if (event->type == JackSessionSaveAndQuit)
x_quitNow = true;

jack_session_event_free(event);
jackbridge_session_event_free(event);
}
#endif

@@ -97,21 +97,21 @@ void reconnect_ports()
{
x_needReconnect = false;

jack_port_t* const jPlayPort1 = jack_port_by_name(jClient, gIsOutput ? "system:playback_1" : "system:capture_1");
jack_port_t* const jPlayPort2 = jack_port_by_name(jClient, gIsOutput ? "system:playback_2" : "system:capture_2");
std::vector<char*> jPortList1(jack_port_get_all_connections_as_vector(jClient, jPlayPort1));
std::vector<char*> jPortList2(jack_port_get_all_connections_as_vector(jClient, jPlayPort2));
jack_port_t* const jPlayPort1 = jackbridge_port_by_name(jClient, gIsOutput ? "system:playback_1" : "system:capture_1");
jack_port_t* const jPlayPort2 = jackbridge_port_by_name(jClient, gIsOutput ? "system:playback_2" : "system:capture_2");
std::vector<char*> jPortList1(jackbridge_port_get_all_connections_as_vector(jClient, jPlayPort1));
std::vector<char*> jPortList2(jackbridge_port_get_all_connections_as_vector(jClient, jPlayPort2));

foreach (char* const& thisPortName, jPortList1)
{
jack_port_t* const thisPort = jack_port_by_name(jClient, thisPortName);
jack_port_t* const thisPort = jackbridge_port_by_name(jClient, thisPortName);

if (! (jack_port_is_mine(jClient, thisPort) || jack_port_connected_to(jPort1, thisPortName)))
if (! (jackbridge_port_is_mine(jClient, thisPort) || jackbridge_port_connected_to(jPort1, thisPortName)))
{
if (gIsOutput)
jack_connect(jClient, thisPortName, "M:in1");
jackbridge_connect(jClient, thisPortName, "M:in1");
else
jack_connect(jClient, "Mi:in1", thisPortName);
jackbridge_connect(jClient, "Mi:in1", thisPortName);
}

free(thisPortName);
@@ -119,14 +119,14 @@ void reconnect_ports()

foreach (char* const& thisPortName, jPortList2)
{
jack_port_t* const thisPort = jack_port_by_name(jClient, thisPortName);
jack_port_t* const thisPort = jackbridge_port_by_name(jClient, thisPortName);

if (! (jack_port_is_mine(jClient, thisPort) || jack_port_connected_to(jPort2, thisPortName)))
if (! (jackbridge_port_is_mine(jClient, thisPort) || jackbridge_port_connected_to(jPort2, thisPortName)))
{
if (gIsOutput)
jack_connect(jClient, thisPortName, "M:in2");
jackbridge_connect(jClient, thisPortName, "M:in2");
else
jack_connect(jClient, "Mi:in2", thisPortName);
jackbridge_connect(jClient, "Mi:in2", thisPortName);
}

free(thisPortName);
@@ -159,7 +159,7 @@ public:
displayMeter(1, 0.0f);
displayMeter(2, 0.0f);

int refresh = float(jack_get_buffer_size(jClient)) / jack_get_sample_rate(jClient) * 1000;
int refresh = float(jackbridge_get_buffer_size(jClient)) / jackbridge_get_sample_rate(jClient) * 1000;

m_peakTimerId = startTimer(refresh > 50 ? refresh : 50);
}
@@ -212,26 +212,26 @@ int main(int argc, char* argv[])
#else
jack_options_t jOptions = static_cast<jack_options_t>(JackNoStartServer|JackUseExactName);
#endif
jClient = jack_client_open(gIsOutput ? "M" : "Mi", jOptions, &jStatus);
jClient = jackbridge_client_open(gIsOutput ? "M" : "Mi", jOptions, &jStatus);

if (! jClient)
{
std::string errorString(jack_status_get_error_string(jStatus));
std::string errorString(jackbridge_status_get_error_string(jStatus));
QMessageBox::critical(nullptr, app.translate("MeterW", "Error"), app.translate("MeterW",
"Could not connect to JACK, possible reasons:\n"
"%1").arg(QString::fromStdString(errorString)));
return 1;
}

jPort1 = jack_port_register(jClient, "in1", JACK_DEFAULT_AUDIO_TYPE, gIsOutput ? JackPortIsInput : JackPortIsOutput, 0);
jPort2 = jack_port_register(jClient, "in2", JACK_DEFAULT_AUDIO_TYPE, gIsOutput ? JackPortIsInput : JackPortIsOutput, 0);
jPort1 = jackbridge_port_register(jClient, "in1", JACK_DEFAULT_AUDIO_TYPE, gIsOutput ? JackPortIsInput : JackPortIsOutput, 0);
jPort2 = jackbridge_port_register(jClient, "in2", JACK_DEFAULT_AUDIO_TYPE, gIsOutput ? JackPortIsInput : JackPortIsOutput, 0);

jack_set_process_callback(jClient, process_callback, nullptr);
jack_set_port_connect_callback(jClient, port_callback, nullptr);
jackbridge_set_process_callback(jClient, process_callback, nullptr);
jackbridge_set_port_connect_callback(jClient, port_callback, nullptr);
#ifdef HAVE_JACKSESSION
jack_set_session_callback(jClient, session_callback, argv[0]);
jackbridge_set_session_callback(jClient, session_callback, argv[0]);
#endif
jack_activate(jClient);
jackbridge_activate(jClient);

reconnect_ports();

@@ -244,8 +244,8 @@ int main(int argc, char* argv[])
// App-Loop
int ret = app.exec();

jack_deactivate(jClient);
jack_client_close(jClient);
jackbridge_deactivate(jClient);
jackbridge_client_close(jClient);

return ret;
}

+ 1
- 1
c++/xycontroller/Makefile View File

@@ -35,7 +35,7 @@ OBJS = xycontroller.o \
all: cadence-xycontroller

cadence-xycontroller: $(FILES) $(OBJS)
$(CXX) $(OBJS) $(LINK_FLAGS) -o $@ && $(STRIP) $@
$(CXX) $(OBJS) $(LINK_FLAGS) -ldl -o $@ && $(STRIP) $@

cadence-xycontroller.exe: $(FILES) $(OBJS) icon.o
$(CXX) $(OBJS) icon.o $(LINK_FLAGS) -limm32 -lole32 -luuid -lwinspool -lws2_32 -mwindows -o $@ && $(STRIP) $@


+ 17
- 17
c++/xycontroller/xycontroller.cpp View File

@@ -868,21 +868,21 @@ private:

int process_callback(const jack_nframes_t nframes, void*)
{
void* const midiInBuffer = jack_port_get_buffer(jMidiInPort, nframes);
void* const midiOutBuffer = jack_port_get_buffer(jMidiOutPort, nframes);
void* const midiInBuffer = jackbridge_port_get_buffer(jMidiInPort, nframes);
void* const midiOutBuffer = jackbridge_port_get_buffer(jMidiOutPort, nframes);

if (! (midiInBuffer && midiOutBuffer))
return 1;

// MIDI In
jack_midi_event_t midiEvent;
uint32_t midiEventCount = jack_midi_get_event_count(midiInBuffer);
uint32_t midiEventCount = jackbridge_midi_get_event_count(midiInBuffer);

qMidiInData.lock();

for (uint32_t i=0; i < midiEventCount; i++)
{
if (jack_midi_event_get(&midiEvent, midiInBuffer, i) != 0)
if (! jackbridge_midi_event_get(&midiEvent, midiInBuffer, i))
break;

if (midiEvent.size == 1)
@@ -898,7 +898,7 @@ int process_callback(const jack_nframes_t nframes, void*)
qMidiInData.unlock();

// MIDI Out
jack_midi_clear_buffer(midiOutBuffer);
jackbridge_midi_clear_buffer(midiOutBuffer);
qMidiOutData.lock();

if (! qMidiOutData.isEmpty())
@@ -910,7 +910,7 @@ int process_callback(const jack_nframes_t nframes, void*)
data[0] = d1;
data[1] = d2;
data[2] = d3;
jack_midi_event_write(midiOutBuffer, 0, data, 3);
jackbridge_midi_event_write(midiOutBuffer, 0, data, 3);
}
}
qMidiOutData.unlock();
@@ -930,12 +930,12 @@ void session_callback(jack_session_event_t* const event, void* const arg)

event->command_line = strdup(filepath.toUtf8().constData());

jack_session_reply(jClient, event);
jackbridge_session_reply(jClient, event);

if (event->type == JackSessionSaveAndQuit)
QApplication::instance()->quit();

jack_session_event_free(event);
jackbridge_session_event_free(event);
}
#endif

@@ -962,25 +962,25 @@ int main(int argc, char* argv[])
#else
jack_options_t jOptions = static_cast<jack_options_t>(JackNoStartServer);
#endif
jClient = jack_client_open("XY-Controller", jOptions, &jStatus);
jClient = jackbridge_client_open("XY-Controller", jOptions, &jStatus);

if (! jClient)
{
std::string errorString(jack_status_get_error_string(jStatus));
std::string errorString(jackbridge_status_get_error_string(jStatus));
QMessageBox::critical(nullptr, app.translate("XY-Controller", "Error"), app.translate("XY-Controller",
"Could not connect to JACK, possible reasons:\n"
"%1").arg(QString::fromStdString(errorString)));
return 1;
}

jMidiInPort = jack_port_register(jClient, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
jMidiOutPort = jack_port_register(jClient, "midi_out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
jMidiInPort = jackbridge_port_register(jClient, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
jMidiOutPort = jackbridge_port_register(jClient, "midi_out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);

jack_set_process_callback(jClient, process_callback, nullptr);
jackbridge_set_process_callback(jClient, process_callback, nullptr);
#ifdef HAVE_JACKSESSION
jack_set_session_callback(jClient, session_callback, argv[0]);
jackbridge_set_session_callback(jClient, session_callback, argv[0]);
#endif
jack_activate(jClient);
jackbridge_activate(jClient);

// Show GUI
XYControllerW gui;
@@ -989,8 +989,8 @@ int main(int argc, char* argv[])
// App-Loop
int ret = app.exec();

jack_deactivate(jClient);
jack_client_close(jClient);
jackbridge_deactivate(jClient);
jackbridge_client_close(jClient);

return ret;
}

+ 0
- 7
data/windows/build-win32.sh View File

@@ -21,8 +21,6 @@ export UIC=$MINGW-uic
export STRIP=$MINGW-strip
export WINDRES=$MINGW-windres

export PKG_CONFIG_PATH="`pwd`/data/windows:$MINGW_PATH/lib/pkgconfig"

export WINEPREFIX=~/.winepy3

export PYTHON_EXE="C:\\\\Python33\\\\python.exe"
@@ -34,11 +32,6 @@ export PYRCC="wine C:\\\\Python33\\\\Lib\\\\site-packages\\\\PyQt4\\\\pyrcc4.exe
export CFLAGS="-DPTW32_STATIC_LIB -I$MINGW_PATH/include"
export CXXFLAGS="-DPTW32_STATIC_LIB -DWIN32 -I$MINGW_PATH/include"

# win32 jack libs
cp -r "$WINEPREFIX/drive_c/Program Files (x86)/Jack/includes/" ./data/windows/
cp -r "$WINEPREFIX/drive_c/Program Files (x86)/Jack/lib/" ./data/windows/
cp "$WINEPREFIX/drive_c/windows/syswow64/libjack.dll" ./data/windows/lib/

# Clean build
make clean



+ 0
- 7
data/windows/build-win64.sh View File

@@ -21,8 +21,6 @@ export UIC=$MINGW-uic
export STRIP=$MINGW-strip
export WINDRES=$MINGW-windres

export PKG_CONFIG_PATH="`pwd`/data/windows:$MINGW_PATH/lib/pkgconfig"

export WINEPREFIX=~/.winepy3_x64

export PYTHON_EXE="C:\\\\Python33\\\\python.exe"
@@ -34,11 +32,6 @@ export PYRCC="wine C:\\\\Python33\\\\Lib\\\\site-packages\\\\PyQt4\\\\pyrcc4.exe
export CFLAGS="-DPTW32_STATIC_LIB -I$MINGW_PATH/include"
export CXXFLAGS="-DPTW32_STATIC_LIB -DWIN32 -I$MINGW_PATH/include"

# win32 jack libs
cp -r "$WINEPREFIX/drive_c/Program Files/Jack/includes/" ./data/windows/
cp -r "$WINEPREFIX/drive_c/Program Files/Jack/lib/" ./data/windows/
cp "$WINEPREFIX/drive_c/windows/syswow64/libjack.dll" ./data/windows/lib/

# Clean build
make clean



+ 0
- 10
data/windows/jack.pc View File

@@ -1,10 +0,0 @@
prefix=../../data/windows
exec_prefix=../../data/windows
libdir=../../data/windows/lib
includedir=../../data/windows/includes

Name: jack
Description: the Jack Audio Connection Kit: a low-latency synchronous callback-based media server
Version: 1.9.9.5
Libs: -L../../data/windows/lib -ljack
Cflags: -I../../data/windows/includes

Loading…
Cancel
Save