From c26ebafa6299107b62eece442889e390f8a1d30b Mon Sep 17 00:00:00 2001 From: Elias Naur Date: Mon, 16 Jan 2006 15:54:50 +0000 Subject: [PATCH] OpenAL: Split platform dependent code from extal.c into platform subdirs. Made nCreate take a path instead of an array of paths. --- src/java/org/lwjgl/openal/AL.java | 15 +- src/native/common/extal.c | 244 ------------------------ src/native/common/extal.h | 11 +- src/native/common/org_lwjgl_openal_AL.c | 11 +- src/native/linux/linux_al.c | 64 +++++++ src/native/macosx/macosx_al.c | 115 +++++++++++ src/native/win32/win32_al.c | 70 +++++++ 7 files changed, 272 insertions(+), 258 deletions(-) delete mode 100644 src/native/common/extal.c create mode 100644 src/native/linux/linux_al.c create mode 100644 src/native/macosx/macosx_al.c create mode 100644 src/native/win32/win32_al.c diff --git a/src/java/org/lwjgl/openal/AL.java b/src/java/org/lwjgl/openal/AL.java index 0423d69c..350e490b 100644 --- a/src/java/org/lwjgl/openal/AL.java +++ b/src/java/org/lwjgl/openal/AL.java @@ -65,7 +65,7 @@ public final class AL { * * @param oalPaths Array of strings containing paths to search for OpenAL library */ - private static native void nCreate(String[] oalPaths) throws LWJGLException; + private static native void nCreate(String oalPath) throws LWJGLException; /** * Native method the destroy the AL @@ -99,8 +99,17 @@ public final class AL { "openal", "libopenal.so", "openal", "openal.dylib"}, AL.class.getClassLoader()); LWJGLUtil.log("Found " + oalPaths.length + " OpenAL paths"); - nCreate(oalPaths); - created = true; + for (int i = 0; i < oalPaths.length; i++) { + try { + nCreate(oalPaths[i]); + created = true; + break; + } catch (LWJGLException e) { + LWJGLUtil.log("Failed to load " + oalPaths[i] + ": " + e.getMessage()); + } + } + if (!created) + throw new LWJGLException("Could not locate OpenAL library."); try { AL10.initNativeStubs(); diff --git a/src/native/common/extal.c b/src/native/common/extal.c deleted file mode 100644 index ca863fc4..00000000 --- a/src/native/common/extal.c +++ /dev/null @@ -1,244 +0,0 @@ -/* - * Copyright (c) 2002-2004 LWJGL Project - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of 'LWJGL' nor the names of - * its contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include -#include -#include -#include "extal.h" -#include "common_tools.h" - -#ifdef _X11 -#include -#endif - -/** - * $Id$ - * - * This file contains the AL extension assigning mechanism - * - * @author Brian Matzon - * @version $Revision$ - */ -#ifdef _WIN32 -/* Handle to OpenAL Library */ -static HMODULE handleOAL; -#endif -#ifdef _X11 -static void* handleOAL; -#endif -#ifdef _MACOSX -#include -#include -#include -#include - -static const struct mach_header* handleOAL = NULL; -static CFBundleRef openal_bundle = NULL; -#endif - -typedef ALvoid* (ALAPIENTRY *alGetProcAddressPROC)( ALubyte* fname ); -static alGetProcAddressPROC alGetProcAddress = NULL; - -/* Loads OpenAL */ -static bool LoadOpenAL(JNIEnv *env, jobjectArray oalPaths); - -/* Unloads OpenAL */ -static void UnLoadOpenAL(void); - -static void *NativeGetFunctionPointer(const char *function) { -#ifdef _WIN32 - return GetProcAddress(handleOAL, function); -#endif -#ifdef _X11 - return dlsym(handleOAL, function); -#endif -#ifdef _MACOSX - char *mac_symbol_name = (char *)malloc((strlen(function) + 2)*sizeof(char)); - void *address = NULL; - if (mac_symbol_name == NULL) - return NULL; - mac_symbol_name[0] = '_'; - strcpy(&(mac_symbol_name[1]), function); - if (handleOAL != NULL) { - NSSymbol symbol = NSLookupSymbolInImage(handleOAL, mac_symbol_name, NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR); - if (symbol != NULL) { - address = NSAddressOfSymbol(symbol); - } - } else if (openal_bundle != NULL) { - CFStringRef cf_function = CFStringCreateWithCString(NULL, function, kCFStringEncodingUTF8); - address = CFBundleGetFunctionPointerForName(openal_bundle, cf_function); - CFRelease(cf_function); - } - free(mac_symbol_name); - return address; -#endif -} - -/** - * Retrieves a pointer to the named function - * - * @param function Name of function - * @return pointer to named function, or NULL if not found - */ -static void* extal_GetProcAddress(const char* function) { - void *p = NativeGetFunctionPointer(function); - if (p == NULL) { - printfDebug("Could not locate symbol %s\n", function); - } - return p; -} - -#ifdef _MACOSX -static CFBundleRef tryLoadFramework(JNIEnv *env) { - CFStringRef framework_path = CFSTR("/System/Library/Frameworks/OpenAL.framework"); - if (framework_path == NULL) { - printfDebugJava(env, "Failed to allocate string"); - return NULL; - } - CFURLRef url = CFURLCreateWithFileSystemPath(NULL, framework_path, kCFURLPOSIXPathStyle, TRUE); - if (url == NULL) { - printfDebugJava(env, "Failed to allocate URL"); - return NULL; - } - CFBundleRef openal_bundle = CFBundleCreate(NULL, url); - CFRelease(url); - return openal_bundle; -} -#endif - -static bool tryLoadLibrary(JNIEnv *env, jstring path) { -#ifdef _WIN32 - char *path_str = GetStringNativeChars(env, path); - printfDebugJava(env, "Testing '%s'", path_str); - handleOAL = LoadLibrary(path_str); - if (handleOAL != NULL) { - printfDebugJava(env, "Found OpenAL at '%s'", path_str); - } - free(path_str); - return handleOAL != NULL; -#endif -#ifdef _X11 - char *path_str = GetStringNativeChars(env, path); - printfDebugJava(env, "Testing '%s'", path_str); - handleOAL = dlopen(path_str, RTLD_LAZY); - if (handleOAL != NULL) { - printfDebugJava(env, "Found OpenAL at '%s'", path_str); - } - free(path_str); - return handleOAL != NULL; -#endif -#ifdef _MACOSX - const char *path_str = (*env)->GetStringUTFChars(env, path, NULL); - printfDebugJava(env, "Testing '%s'", path_str); - handleOAL = NSAddImage(path_str, NSADDIMAGE_OPTION_RETURN_ON_ERROR); - if (handleOAL != NULL) { - printfDebugJava(env, "Found OpenAL at '%s'", path_str); - } - (*env)->ReleaseStringUTFChars(env, path, path_str); - openal_bundle = tryLoadFramework(env); - if (openal_bundle != NULL) - printfDebugJava(env, "Found OpenAL Bundle"); - return handleOAL != NULL || openal_bundle != NULL; -#endif -} - -/** - * Loads the OpenAL Library - */ -static bool LoadOpenAL(JNIEnv *env, jobjectArray oalPaths) { - jsize pathcount = (*env)->GetArrayLength(env, oalPaths); - int i; - jstring path; - - for(i=0;iGetObjectArrayElement(env, oalPaths, i); - if (tryLoadLibrary(env, path)) { - return true; - } - } - throwException(env, "Could not load openal library."); - return false; -} - -/** - * Unloads the OpenAL Library - */ -static void UnLoadOpenAL() { -#ifdef _WIN32 - FreeLibrary(handleOAL); -#endif -#ifdef _X11 - if (handleOAL != NULL) { - dlclose(handleOAL); - handleOAL = NULL; - } -#endif -#ifdef _MACOSX - if (openal_bundle != NULL) { - CFRelease(openal_bundle); - openal_bundle = NULL; - } -#endif -} - -/** - * Initializes OpenAL by loading the library - */ -void InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths) { - if(handleOAL != NULL) { - return; - } - - //load our library - if (!LoadOpenAL(env, oalPaths)) { - return; - } - alGetProcAddress = (alGetProcAddressPROC)extal_GetProcAddress("alGetProcAddress"); - if (alGetProcAddress == NULL) { - DeInitializeOpenAL(); - throwException(env, "Could not load alGetProcAddress function pointer."); - return; - } -} - -/** - * Called to deinitialize OpenAL - */ -void DeInitializeOpenAL() { - UnLoadOpenAL(); - handleOAL = 0; -} - -void extal_InitializeClass(JNIEnv *env, jclass clazz, int num_functions, JavaMethodAndExtFunction *functions) { - ext_InitializeClass(env, clazz, &extal_GetProcAddress, num_functions, functions); -} - diff --git a/src/native/common/extal.h b/src/native/common/extal.h index 185d5105..b27b3cb3 100644 --- a/src/native/common/extal.h +++ b/src/native/common/extal.h @@ -44,8 +44,6 @@ extern "C" { #endif -void extal_InitializeClass(JNIEnv *env, jclass clazz, int num_functions, JavaMethodAndExtFunction *functions); - #if defined(_WIN32) #ifdef _OPENAL32LIB #define ALCAPI __declspec(dllexport) @@ -159,11 +157,12 @@ typedef double ALdouble; /** void type (for opaque pointers only) */ typedef void ALvoid; +void* extal_GetProcAddress(const char* function); -void InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths); -void DeInitializeOpenAL(); - -//extern alGetProcAddressPROC alGetProcAddress; +/* Platform dependent functions */ +void *NativeGetFunctionPointer(const char *function); +bool tryLoadLibrary(JNIEnv *env, jstring path); +void UnLoadOpenAL(); #ifdef __cplusplus } diff --git a/src/native/common/org_lwjgl_openal_AL.c b/src/native/common/org_lwjgl_openal_AL.c index 20099c60..793a9565 100644 --- a/src/native/common/org_lwjgl_openal_AL.c +++ b/src/native/common/org_lwjgl_openal_AL.c @@ -30,17 +30,18 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include #include "org_lwjgl_openal_AL.h" - -/* OpenAL includes */ #include "extal.h" -JNIEXPORT void JNICALL Java_org_lwjgl_openal_AL_nCreate (JNIEnv *env, jclass clazz, jobjectArray oalPaths) { - InitializeOpenAL(env, oalPaths); +JNIEXPORT void JNICALL Java_org_lwjgl_openal_AL_nCreate(JNIEnv *env, jclass clazz, jstring oalPath) { + if (!tryLoadLibrary(env, oalPath)) { + throwException(env, "Could not load OpenAL library"); + } } JNIEXPORT void JNICALL Java_org_lwjgl_openal_AL_nDestroy(JNIEnv *env, jclass clazz) { - DeInitializeOpenAL(); + UnLoadOpenAL(); } JNIEXPORT void JNICALL Java_org_lwjgl_openal_AL_resetNativeStubs(JNIEnv *env, jclass clazz, jclass al_class) { diff --git a/src/native/linux/linux_al.c b/src/native/linux/linux_al.c new file mode 100644 index 00000000..9c50bd84 --- /dev/null +++ b/src/native/linux/linux_al.c @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include "org_lwjgl_openal_AL.h" +#include "extal.h" +#include "common_tools.h" + +#include + +static void* handleOAL; + +void *NativeGetFunctionPointer(const char *function) { + return dlsym(handleOAL, function); +} + +bool tryLoadLibrary(JNIEnv *env, jstring path) { + char *path_str = GetStringNativeChars(env, path); + printfDebugJava(env, "Testing '%s'", path_str); + handleOAL = dlopen(path_str, RTLD_LAZY); + if (handleOAL != NULL) { + printfDebugJava(env, "Found OpenAL at '%s'", path_str); + } + free(path_str); + return handleOAL != NULL; +} + +void UnLoadOpenAL() { + if (handleOAL != NULL) { + dlclose(handleOAL); + handleOAL = NULL; + } +} diff --git a/src/native/macosx/macosx_al.c b/src/native/macosx/macosx_al.c new file mode 100644 index 00000000..630f5f14 --- /dev/null +++ b/src/native/macosx/macosx_al.c @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "extal.h" +#include "common_tools.h" + +/** + * $Id$ + * + * This file contains the AL extension assigning mechanism + * + * @author Brian Matzon + * @version $Revision$ + */ + +static const struct mach_header* handleOAL = NULL; +static CFBundleRef openal_bundle = NULL; + +void *NativeGetFunctionPointer(const char *function) { + char *mac_symbol_name = (char *)malloc((strlen(function) + 2)*sizeof(char)); + void *address = NULL; + if (mac_symbol_name == NULL) + return NULL; + mac_symbol_name[0] = '_'; + strcpy(&(mac_symbol_name[1]), function); + if (handleOAL != NULL) { + NSSymbol symbol = NSLookupSymbolInImage(handleOAL, mac_symbol_name, NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR); + if (symbol != NULL) { + address = NSAddressOfSymbol(symbol); + } + } else if (openal_bundle != NULL) { + CFStringRef cf_function = CFStringCreateWithCString(NULL, function, kCFStringEncodingUTF8); + address = CFBundleGetFunctionPointerForName(openal_bundle, cf_function); + CFRelease(cf_function); + } + free(mac_symbol_name); + return address; +} + +static CFBundleRef tryLoadFramework(JNIEnv *env) { + CFStringRef framework_path = CFSTR("/System/Library/Frameworks/OpenAL.framework"); + if (framework_path == NULL) { + printfDebugJava(env, "Failed to allocate string"); + return NULL; + } + CFURLRef url = CFURLCreateWithFileSystemPath(NULL, framework_path, kCFURLPOSIXPathStyle, TRUE); + if (url == NULL) { + printfDebugJava(env, "Failed to allocate URL"); + return NULL; + } + CFBundleRef openal_bundle = CFBundleCreate(NULL, url); + CFRelease(url); + return openal_bundle; +} + +bool tryLoadLibrary(JNIEnv *env, jstring path) { + const char *path_str = (*env)->GetStringUTFChars(env, path, NULL); + printfDebugJava(env, "Testing '%s'", path_str); + handleOAL = NSAddImage(path_str, NSADDIMAGE_OPTION_RETURN_ON_ERROR); + if (handleOAL != NULL) { + printfDebugJava(env, "Found OpenAL at '%s'", path_str); + } + (*env)->ReleaseStringUTFChars(env, path, path_str); + openal_bundle = tryLoadFramework(env); + if (openal_bundle != NULL) + printfDebugJava(env, "Found OpenAL Bundle"); + return handleOAL != NULL || openal_bundle != NULL; +} + +/** + * Unloads the OpenAL Library + */ +void UnLoadOpenAL() { + if (openal_bundle != NULL) { + CFRelease(openal_bundle); + openal_bundle = NULL; + } +} + diff --git a/src/native/win32/win32_al.c b/src/native/win32/win32_al.c new file mode 100644 index 00000000..42717c08 --- /dev/null +++ b/src/native/win32/win32_al.c @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include "extal.h" +#include "common_tools.h" + +/** + * $Id$ + * + * This file contains the AL extension assigning mechanism + * + * @author Brian Matzon + * @version $Revision$ + */ +/* Handle to OpenAL Library */ +static HMODULE handleOAL; + +void *NativeGetFunctionPointer(const char *function) { + return GetProcAddress(handleOAL, function); +} + +bool tryLoadLibrary(JNIEnv *env, jstring path) { + char *path_str = GetStringNativeChars(env, path); + printfDebugJava(env, "Testing '%s'", path_str); + handleOAL = LoadLibrary(path_str); + if (handleOAL != NULL) { + printfDebugJava(env, "Found OpenAL at '%s'", path_str); + } + free(path_str); + return handleOAL != NULL; +} + +/** + * Unloads the OpenAL Library + */ +void UnLoadOpenAL() { + FreeLibrary(handleOAL); +}