(JNIEnv *, jclass, jint level) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_setLoggingLevelN");

switch (level) {

case jackAudio4Java_Jack_NATIVE_LEVEL_TRACE:

spdlog::set_level(spdlog::level::trace);

SPDLOG_INFO("Native Log-level now set to \"trace\"");

break;

case jackAudio4Java_Jack_NATIVE_LEVEL_DEBUG:

spdlog::set_level(spdlog::level::debug);

SPDLOG_INFO("Native Log-level now set to \"debug\"");

break;

case jackAudio4Java_Jack_NATIVE_LEVEL_INFO:

spdlog::set_level(spdlog::level::info);

SPDLOG_INFO("Native Log-level now set to \"info\"");

break;

case jackAudio4Java_Jack_NATIVE_LEVEL_WARN:

SPDLOG_INFO("Native Log-level now set to \"warn\"");

spdlog::set_level(spdlog::level::warn);

break;

case jackAudio4Java_Jack_NATIVE_LEVEL_ERROR:

SPDLOG_INFO("Native Log-level now set to \"err\"");

spdlog::set_level(spdlog::level::err);

break;

case jackAudio4Java_Jack_NATIVE_LEVEL_CRITICAL:

SPDLOG_INFO("Native Log-level now set to \"critical\"");

spdlog::set_level(spdlog::level::critical);

break;

case jackAudio4Java_Jack_NATIVE_LEVEL_OFF:

SPDLOG_INFO("Native Log-level now set to \"off\"");

spdlog::set_level(spdlog::level::off);

break;

default:

SPDLOG_INFO("Native Log-level now set to \"trace\"");

spdlog::set_level(spdlog::level::trace);

}

(JNIEnv *env, jclass, jobject majorRef, jobject minorRef, jobject microRef, jobject protoRef) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_getJackVersionN");

int majorVal = -1;

int minorVal = -1;

int microVal = -1;

int protoVal = -1;

jack_get_version(&majorVal, &minorVal, &microVal, &protoVal);

if (majorRef) types::Int::setValue(env, (types::jIntObject) majorRef, majorVal);

if (minorRef) types::Int::setValue(env, (types::jIntObject) minorRef, minorVal);

if (microRef) types::Int::setValue(env, (types::jIntObject) microRef, microVal);

if (protoRef) types::Int::setValue(env, (types::jIntObject) protoRef, protoVal);

(JNIEnv *env, jclass) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_getJniVersionN");

return env->GetVersion();

(JNIEnv *, jclass) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portNameSizeN");

return jack_port_name_size();

(JNIEnv *, jclass) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portTypeSizeN");

return jack_port_type_size();

(JNIEnv *, jclass) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_clientNameSizeN");

return jack_client_name_size();

(JNIEnv *, jclass, jlong clientHandle) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_clientCloseN");

return jack_client_close((jack_client_t *) clientHandle);

(JNIEnv *env, jclass, jstring clientName, jint openOptions, jobject returnStatus, jstring serverName) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_clientOpenN");

// transform clientName from Java-string to UTF-8 Native string.

const char *clientNameN = nullptr;

if (clientName) clientNameN = env->GetStringUTFChars(clientName, nullptr);

// cast openOptions from "jint" to "jack_options_t" type.

auto openOptionsN = (jack_options_t) openOptions;

// transform serverName from Java-string to UTF-8 Native string.

const char *serverNameN = nullptr;

if (serverName)serverNameN = env->GetStringUTFChars(serverName, nullptr);

// allocate space where Jack will write the return status.

jack_status_t returnStatusN;

// and here we go...

auto clientHandle = jack_client_open(clientNameN, openOptionsN, &returnStatusN, serverNameN);

// free resources

if (serverNameN) env->ReleaseStringUTFChars(serverName, serverNameN);

if (clientNameN) env->ReleaseStringUTFChars(clientName, clientNameN);

// push the return status into the given container

if (returnStatus) types::Int::setValue(env, (types::jIntObject) returnStatus, returnStatusN);

return (jlong) clientHandle;

(JNIEnv *env, jclass, jlong clientHandle) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_getClientNameN");

char *clientName = jack_get_client_name((jack_client_t *) clientHandle);

return env->NewStringUTF(clientName);

(JNIEnv *env, jclass, jlong client, jstring portName, jstring portType, jlong portFlags, jlong bufferSize) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portRegisterN");

// transform portName and portType from Java-string to UTF-8 Native string.

const char *portNameN = nullptr;

if (portName) portNameN = env->GetStringUTFChars(portName, nullptr);

const char *portTypeN = nullptr;

if (portType) portTypeN = env->GetStringUTFChars(portType, nullptr);

// and here we go...

auto portHandle = jack_port_register(reinterpret_cast<jack_client_t *>(client), portNameN, portTypeN, portFlags,

bufferSize);

if (portType) env->ReleaseStringUTFChars(portType,portTypeN);

if (portName) env->ReleaseStringUTFChars(portName,portNameN);

return reinterpret_cast<jlong> (portHandle);

(JNIEnv *, jclass, jlong client, jlong port) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portUnregisterN");

return jack_port_unregister(reinterpret_cast<jack_client_t *> (client), reinterpret_cast<jack_port_t *> (port));

if (processListener == nullptr) {

// java callback routine not set...

return -1;

}

if (processListener_onProcess == nullptr) {

// java callback routine not set...

return -1;

}

JNIEnv *env = getJNIEnvForCallbackThread();

jint result;

if (env) {

// here we go... now we call the Java implementation of the ProcessCallback.

result = env->CallIntMethod(processListener, processListener_onProcess, nframes);

} else {

result = -1;

SPDLOG_ERROR("Could not attach to the current thread");

}

return result;

(JNIEnv *env, jclass, jlong client, jobject newListener) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_registerProcessListenerN");

if (newListener == nullptr) {

SPDLOG_WARN("process callbacks now switched off.");

processListener_onProcess = nullptr;

return -1;

}

// cache a pointer to the Java machine, for use in the "getJNIEnvForCallbackThread" routine.

env->GetJavaVM(&jvm);

// pin the process Listener Object, so it will not be garbage collected.

processListener = env->NewGlobalRef(newListener);

// cache the method identifier, for use in the "localProcessCallback" routine.

jclass clazz = env->GetObjectClass(processListener);

processListener_onProcess = env->GetMethodID(clazz, "onProcess", "(I)I");

if (processListener_onProcess == nullptr) {

SPDLOG_ERROR("Could not register the Process Listener.");

return -1;

}

return jack_set_process_callback(reinterpret_cast<jack_client_t *>(client), localProcessCallback, nullptr);

SPDLOG_TRACE("localShutdownCallback");

if (shutdownListener == nullptr) {

SPDLOG_ERROR("java shutdown-listener object not set...");

return;

}

if (shutdownListener_onShutdown == nullptr) {

SPDLOG_ERROR("java onShutdown callback routine not set...");

return;

}

if (jvm == nullptr) {

SPDLOG_ERROR("jvm is NULL");

return;

}

JNIEnv *env;

jint success = jvm->AttachCurrentThread((void **) &env, NULL);

if (success != JNI_OK) {

SPDLOG_ERROR("Could not attach to the current thread");

return;

}

// Everything is fine. At last, let's call the Java "onShutdown" method.

env->CallVoidMethod(shutdownListener, shutdownListener_onShutdown);

(JNIEnv *env, jclass, jlong client, jobject newListener) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_registerShutdownListenerN");

if (newListener == nullptr) {

return -1;

}

// cache a pointer to the Java machine, for use in the `localShutdownCallback` routine.

env->GetJavaVM(&jvm);

// pin and than cache the process Listener Object, so it will not be garbage collected.

shutdownListener = env->NewGlobalRef(newListener);

// cache the method identifier, for use in the `localShutdownCallback` routine.

jclass clazz = env->GetObjectClass(shutdownListener);

shutdownListener_onShutdown = env->GetMethodID(clazz, "onShutdown", "()V");

if (shutdownListener_onShutdown == nullptr) {

SPDLOG_ERROR("Could not register the Shutdown Listener.");

return -1;

}

// install the local callback routine.

jack_on_shutdown(reinterpret_cast<jack_client_t *>(client), localShutdownCallback, nullptr);

SPDLOG_TRACE("Java_jackAudio4Java_Jack_registerShutdownListenerN - done");

return 0;

(JNIEnv *, jclass, jlong client) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_getSampleRateN");

return jack_get_sample_rate(reinterpret_cast<jack_client_t *>(client));

(JNIEnv *, jclass, jlong client) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_activateN");

return jack_activate(reinterpret_cast<jack_client_t *>(client));

(JNIEnv *, jclass, jlong client) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_deactivateN");

return jack_deactivate(reinterpret_cast<jack_client_t *>(client));

if (!ports) return 0;

int i = 0;

while (ports[i] != nullptr) {

i++;

}

return i;

(JNIEnv *env, jclass, jlong client, jstring portNamePatternJ, jstring typeNamePatternJ, jlong portFlags) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_getPortsN");

const char *portNamePatternN = nullptr;

if (portNamePatternJ) portNamePatternN = env->GetStringUTFChars(portNamePatternJ, nullptr);

const char *typeNamePatternN = nullptr;

if (typeNamePatternJ) typeNamePatternN = env->GetStringUTFChars(typeNamePatternJ, nullptr);

auto ports = jack_get_ports(reinterpret_cast<jack_client_t *>(client),

portNamePatternN,

typeNamePatternN,

portFlags);

if (typeNamePatternN) env->ReleaseStringUTFChars(typeNamePatternJ, typeNamePatternN);

if (portNamePatternN) env->ReleaseStringUTFChars(portNamePatternJ, portNamePatternN);

if (ports == nullptr) return nullptr;

int count = portCount(ports);

if (count == 0) {

return nullptr;

}

auto stringClazz = env->FindClass("java/lang/String");

auto result = env->NewObjectArray(count, stringClazz, nullptr);

for (int i = 0; i < count; i++) {

auto portNameI = env->NewStringUTF(ports[i]);

env->SetObjectArrayElement(result, i, portNameI);

env->DeleteLocalRef(portNameI);

}

free(ports);

return result;

(JNIEnv *env, jclass, jlong portHandle) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portNameN");

const char *portName = jack_port_name(reinterpret_cast<jack_port_t *>( portHandle));

return env->NewStringUTF(portName);

(JNIEnv *env, jclass, jlong portHandle) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portShortNameN");

const char *portName = jack_port_short_name(reinterpret_cast<jack_port_t *>( portHandle));

return env->NewStringUTF(portName);

(JNIEnv *env, jclass, jlong client, jstring sourcePort, jstring destinationPort) {

SPDLOG_TRACE("Java_jackAudio4Java_Jack_connectN");

// transform from Java-string to UTF-8 Native string.

const char *sourcePortN = nullptr;

if (sourcePort) sourcePortN = env->GetStringUTFChars(sourcePort, nullptr);

const char *destinationPortN = nullptr;

if (destinationPort) destinationPortN = env->GetStringUTFChars(destinationPort, nullptr);

// the native call

int result = jack_connect(reinterpret_cast<jack_client_t *>(client), sourcePortN, destinationPortN);

// free resources

if (destinationPort) env->ReleaseStringUTFChars(destinationPort, destinationPortN);

if (sourcePort) env->ReleaseStringUTFChars(sourcePort, sourcePortN);

return result;

(JNIEnv * env, jclass, jlong client, jstring portName){

SPDLOG_TRACE("Java_jackAudio4Java_Jack_portByNameN");

// transform from Java-string to UTF-8 Native string.

const char *portNameN = nullptr;

if (portName) portNameN = env->GetStringUTFChars(portName, nullptr);

// the native call

auto portHandle = jack_port_by_name(reinterpret_cast<jack_client_t *>(client), portNameN);

// free resources

if (portName) env->ReleaseStringUTFChars(portName, portNameN);

return reinterpret_cast<jlong> (portHandle);

}