Several changes, uses newest lwjgl extal, throws exceptions from native code if AL doesn't load correctly and creates Context and Device objects in Native code.

git-svn-id: file:///home/mbien/NetBeansProjects/JOGAMP/joal-sync/git-svn/../svn-server-sync/joal/trunk@69 03bf7f67-59de-4072-a415-9a990d468a3f

8 files changed, 552 insertions, 279 deletions

diff --git a/src/native/alcbind.c b/src/native/alcbind.c
index 48c1404..0917599 100644
--- a/src/native/alcbind.c
+++ b/src/native/alcbind.c
@@ -40,7 +40,7 @@ JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_alcGetErrorNative
   	return alcGetError((ALCdevice*)pointer);
 }
 
-
+/*
 JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
   (JNIEnv *env, jobject obj, jstring deviceName) {
 	printf("Entering openDeviceNative()\n");
@@ -65,13 +65,54 @@ JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
 	printf("Exiting openDeviceNative()\n");
   	return result;
 }
+*/
+JNIEXPORT jobject JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
+  (JNIEnv *env, jobject obj, jstring deviceName) {
+	const char * tokenstring;
+
+	jboolean isCopy = JNI_FALSE;
+	if(deviceName != NULL) {
+		tokenstring = ((*env)->GetStringUTFChars(env, deviceName, &isCopy));
+	} else {
+		tokenstring = NULL;
+	}
+
+	/* get device */
+	ALCdevice* device = alcOpenDevice((ALubyte *) tokenstring);
+
+	/* if error - cleanup and get out */
+	if(device == NULL) {
+		if(tokenstring != NULL) {
+			(*env)->ReleaseStringUTFChars(env, deviceName, tokenstring);
+		}
+		return NULL;
+	}
+
+	/* get ready to create ALCdevice instance */
+	jobject alcDevice_object	= NULL;
+	jclass alcDevice_class		= NULL;
+	jmethodID alcDevice_method	= NULL;
+
+	/* find class and constructor */
+	alcDevice_class		= (*env)->FindClass(env, "net/java/games/joal/ALC$Device");
+	alcDevice_method	= (*env)->GetMethodID(env, alcDevice_class, "<init>", "(I)V");
+
+	/* create instance */
+	alcDevice_object = (*env)->NewObject(env, alcDevice_class, alcDevice_method, (int) device);
+
+	/* clean up */
+	if (tokenstring != NULL)
+		(*env)->ReleaseStringUTFChars(env, deviceName, tokenstring);
+
+	return alcDevice_object;
+}
 
 JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_closeDeviceNative
   (JNIEnv *env, jobject obj, jint pointer) {
 	ALCdevice* device = (ALCdevice*)pointer;
 	alcCloseDevice(device);
 }
-
+/*
 JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
   (JNIEnv *env, jobject obj, jint pointer, jintArray attrs) {
   	ALCdevice* device = (ALCdevice*)pointer;
@@ -86,6 +127,39 @@ JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
 		return ctxPtr;
   	}
 }
+*/
+
+JNIEXPORT jobject JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
+  (JNIEnv *env, jobject obj, jint deviceAddress, jintArray attrs) {
+   ALint* address = NULL;
+
+  	if(attrs != NULL) {
+	  	address = (ALint*)(*env)->GetPrimitiveArrayCritical(env,attrs,0);
+	}
+    ALCcontext* context = alcCreateContext((ALCdevice*)deviceAddress, address);
+    if(address != NULL) {
+	  	(*env)->ReleasePrimitiveArrayCritical(env,attrs,address,0);    
+    }
+	/* if error - get out */
+	if(context == NULL) {
+		return NULL;
+	}	
+
+	/* get ready to create ALCcontext instance */
+	jobject alcContext_object	= NULL;
+	jclass alcContext_class		= NULL;
+	jmethodID alcContext_method	= NULL;
+
+	/* find class and constructor */
+	alcContext_class	= (*env)->FindClass(env, "net/java/games/joal/ALC$Context");
+	alcContext_method	= (*env)->GetMethodID(env, alcContext_class, "<init>", "(Lnet/java/games/joal/ALC;I)V");
+
+	/* create instance */
+	alcContext_object = (*env)->NewObject(env, alcContext_class, alcContext_method, obj, (int) context);
+
+	return alcContext_object;
+}
+
 
 JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_makeContextCurrentNative
   (JNIEnv *env, jobject obj, jint pointer) {
diff --git a/src/native/alcbind.h b/src/native/alcbind.h
index f4a6212..911940b 100644
--- a/src/native/alcbind.h
+++ b/src/native/alcbind.h
@@ -43,8 +43,17 @@ extern "C" {
  * Method:    openDeviceNative
  * Signature: (Ljava/lang/String;)I
  */
+ /*
 JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
   (JNIEnv *, jobject, jstring);
+*/
+/*
+ * Class:     net_java_games_joal_ALCImpl
+ * Method:    openDeviceNative
+ * Signature: (Ljava/lang/String;)I
+ */
+JNIEXPORT jobject JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
+  (JNIEnv *, jobject, jstring);
 
 /*
  * Class:     net_java_games_joal_ALCImpl
@@ -59,9 +68,12 @@ JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_closeDeviceNative
  * Method:    createContextNative
  * Signature: (I[I)I
  */
+/* 
 JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
   (JNIEnv *, jobject, jint, jintArray);
-
+*/
+JNIEXPORT jobject JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
+  (JNIEnv *, jobject, jint, jintArray);
 /*
  * Class:     net_java_games_joal_ALCImpl
  * Method:    makeContextCurrentNative
diff --git a/src/native/alfactory.c b/src/native/alfactory.c
index d989580..a497c0c 100644
--- a/src/native/alfactory.c
+++ b/src/native/alfactory.c
@@ -33,15 +33,14 @@
 
 #include "alfactory.h"
 #include "extal.h"
-#include <jni.h>
+#include "jni.h"
 
 JNIEXPORT jboolean JNICALL Java_net_java_games_joal_ALFactory_init
   (JNIEnv *env , jclass clazz, jobjectArray oalPaths) {
 	printf("ALFactory.init - Native: Enter\n");
-	jboolean result = InitializeOpenAL(env,oalPaths);
-	printf("ALFactory.init - Native: Test 1 result = %i\n",result);
+	InitializeOpenAL(env,oalPaths);
 	printf("ALFactory.init - Native: Exit\n");
-  	return result;
+  	return 1;
 }
 
 JNIEXPORT jboolean JNICALL Java_net_java_games_joal_ALFactory_deinitialize
diff --git a/src/native/build.xml b/src/native/build.xml
index 7f28128..a0c3b3a 100644
--- a/src/native/build.xml
+++ b/src/native/build.xml
@@ -39,7 +39,7 @@
     <target name="init">
     <property name="cc" value ="gcc"/>
     <property name="no_cygwin" value="-mno-cygwin"/>
-    <property name="sources" value="extal.c eaxfactory.c eaxbind.c alfactory.c alcbind.c albind.c"/>
+    <property name="sources" value="common_tools.c extal.c eaxfactory.c eaxbind.c alfactory.c alcbind.c albind.c"/>
     <property name="specs" value="-specs='./specs.new'"/>
     <condition property="isUnix">
   	    <os family="unix" />
diff --git a/src/native/common_tools.c b/src/native/common_tools.c
new file mode 100644
index 0000000..c38b4b3
--- /dev/null
+++ b/src/native/common_tools.c
@@ -0,0 +1,106 @@
+/* 
+ * Copyright (c) 2002 Light Weight Java Game Library 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 'Light Weight Java Game Library' 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.
+ */
+ 
+/**
+ * $Id$
+ *
+ * @author elias_naur <[email protected]>
+ * @version $Revision$
+ */
+
+#include "common_tools.h"
+
+static void incListStart(event_queue_t *queue) {
+	queue->list_start = (queue->list_start + 1)%EVENT_BUFFER_SIZE;
+}
+
+void initEventQueue(event_queue_t *event_queue) {
+	event_queue->list_start = 0;
+	event_queue->list_end = 0;
+}
+
+void putEventElement(event_queue_t *queue, unsigned char byte) {
+	int next_index = (queue->list_end + 1)%EVENT_BUFFER_SIZE;
+	if (next_index == queue->list_start) {
+#ifdef _DEBUG
+		printf("Event buffer overflow!\n");
+#endif
+		return;
+	}
+	queue->input_event_buffer[queue->list_end] = byte;
+	queue->list_end = next_index;
+}
+
+static int hasMoreEvents(event_queue_t *queue) {
+	return queue->list_start != queue->list_end;
+}
+
+static void copyEvent(event_queue_t *queue, int event_size, int event_index) {
+	int output_index = event_index*event_size;
+	int i;
+	for (i = 0; i < event_size; i++) {
+		queue->output_event_buffer[output_index] = queue->input_event_buffer[queue->list_start];
+                incListStart(queue);
+		output_index++;
+	}
+}
+
+int copyEvents(event_queue_t *event_queue, int event_size) {
+	int num_events = 0;
+	while (hasMoreEvents(event_queue)) {
+		copyEvent(event_queue, event_size, num_events);
+		num_events++;
+	}
+	return num_events;
+}
+
+unsigned char *getOutputList(event_queue_t *queue) {
+	return queue->output_event_buffer;
+}
+
+int getEventBufferSize(event_queue_t *event_queue) {
+	return EVENT_BUFFER_SIZE;
+}
+
+static void throwGeneralException(JNIEnv * env, const char *exception_name, const char * err) {
+	jclass cls = (*env)->FindClass(env,exception_name);
+	(*env)->ThrowNew(env,cls, err);
+	(*env)->DeleteLocalRef(env,cls);
+}
+
+void throwOpenALException(JNIEnv * env, const char * err) {
+	throwGeneralException(env, "net/java/games/joal/OpenALException", err);
+}
+
+void throwException(JNIEnv * env, const char * err) {
+	throwGeneralException(env, "java/lang/Exception", err);
+}
diff --git a/src/native/common_tools.h b/src/native/common_tools.h
new file mode 100644
index 0000000..2298728
--- /dev/null
+++ b/src/native/common_tools.h
@@ -0,0 +1,64 @@
+/* 
+ * Copyright (c) 2002 Light Weight Java Game Library 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 'Light Weight Java Game Library' 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.
+ */
+ 
+/**
+ * $Id$
+ *
+ * @author elias_naur <[email protected]>
+ * @version $Revision$
+ */
+
+#ifndef _COMMON_TOOLS_H
+#define _COMMON_TOOLS_H
+
+#include <jni.h>
+
+// Must be x * max_event_size + 1
+#define EVENT_BUFFER_SIZE (25 * 4 + 1)
+
+typedef struct {
+	unsigned char input_event_buffer[EVENT_BUFFER_SIZE];
+	unsigned char output_event_buffer[EVENT_BUFFER_SIZE];
+
+	int list_start;
+	int list_end;
+} event_queue_t;
+
+extern void initEventQueue(event_queue_t *event_queue);
+extern int copyEvents(event_queue_t *event_queue, int event_size);
+extern void putEventElement(event_queue_t *queue, unsigned char byte);
+extern unsigned char *getOutputList(event_queue_t *queue);
+extern int getEventBufferSize(event_queue_t *event_queue);
+extern void throwException(JNIEnv *env, const char *msg);
+extern void throwOpenALException(JNIEnv * env, const char * err);
+
+#endif
diff --git a/src/native/extal.c b/src/native/extal.c
index e264db2..45947dc 100644
--- a/src/native/extal.c
+++ b/src/native/extal.c
@@ -7,15 +7,15 @@
  * met:
  * 
  * * Redistributions of source code must retain the above copyright 
- *   notice, this list of conditions and the following disclaimer.
+ *	 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.
+ *	 notice, this list of conditions and the following disclaimer in the
+ *	 documentation and/or other materials provided with the distribution.
  *
  * * Neither the name of 'Light Weight Java Game Library' nor the names of 
- *   its contributors may be used to endorse or promote products derived 
- *   from this software without specific prior written permission.
+ *	 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
@@ -30,12 +30,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <stdio.h>
-#include <jni.h>
+#include "stdio.h"
 #include "extal.h"
+#include "common_tools.h"
 
 #ifdef _X11
-#include <dlfcn.h>
+#include "dlfcn.h"
 #endif
 
 /**
@@ -118,32 +118,60 @@ alcGetProcAddressPROC alcGetProcAddress = NULL;
 alcGetEnumValuePROC alcGetEnumValue = NULL;
 
 #ifdef _WIN32
-EAXSet  eaxSet;                                         // EAXSet function, ret$
-EAXGet  eaxGet;                                         // EAXGet function, ret$
+EAXSet	eaxSet;																				 // EAXSet function, ret$
+EAXGet	eaxGet;																				 // EAXGet function, ret$
 
 /* Handle to OpenAL Library */
 HMODULE handleOAL;
-#else
+#endif
+#ifdef _X11
 void* handleOAL;
 #endif
+#ifdef _AGL
+#include "mach-o/dyld.h"
+#include "stdlib.h"
+#include "string.h"
+const struct mach_header* handleOAL;
+#endif
 
 /* Loads OpenAL */
-void LoadOpenAL();
+static int LoadOpenAL(JNIEnv *env, jobjectArray oalPaths);
 
 /* Unloads OpenAL */
-void UnLoadOpenAL();
+static void UnLoadOpenAL(void);
 
 /* Gets a pointer to the named function */
-void* GetFunctionPointer(const char* function);
+static void* GetFunctionPointer(const char* function);
 
 /* Loads OpenAL basic functions */
-int LoadAL();
+static int LoadAL(void);
 
 /* Loads OpenAL ALC functions */
-int LoadALC();
+static int LoadALC(void);
 
 /* Loads any extensions to OpenAL */
-int LoadALExtensions();
+static int LoadALExtensions(void);
+
+static void *NativeGetFunctionPointer(const char *function) {
+#ifdef _WIN32
+	return GetProcAddress(handleOAL, function);
+#endif
+#ifdef _X11
+	return dlsym(handleOAL, function);
+#endif
+#ifdef _AGL
+	char *mac_symbol_name = (char *)malloc((strlen(function) + 2)*sizeof(char));
+	if (mac_symbol_name == NULL)
+		return NULL;
+	mac_symbol_name[0] = '_';
+	strcpy(&(mac_symbol_name[1]), function);
+	NSSymbol symbol = NSLookupSymbolInImage(handleOAL, mac_symbol_name, NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
+	free(mac_symbol_name);
+	if (symbol == NULL)
+		return NULL;
+	return NSAddressOfSymbol(symbol);
+#endif
+}
 
 /**
  * Retrieves a pointer to the named function
@@ -151,102 +179,106 @@ int LoadALExtensions();
  * @param function Name of function
  * @return pointer to named function, or NULL if not found
  */
-void* GetFunctionPointer(const char* function) {
-#ifdef _WIN32
-  return GetProcAddress(handleOAL, function);
-#endif
-#ifdef _X11
-  return dlsym(handleOAL, function);
+static void* GetFunctionPointer(const char* function) {
+	void *p = NativeGetFunctionPointer(function);
+	if (p == NULL) {
+#ifdef _DEBUG
+		printf("Could not locate symbol %s\n", function);
 #endif
+	}
+	return p;
 }
 
 /**
  * Loads the OpenAL Library
  */
-void LoadOpenAL(JNIEnv *env, jobjectArray oalPaths) {
-  printf("LoadOpenAL: Enter\n");
-  jsize pathcount = (*env)->GetArrayLength(env,oalPaths);
-//#ifdef _DEBUG
-  printf("LoadOpenAL: test 1 Found %d OpenAL paths\n", pathcount);
-//#endif  
-  int i;
-  for(i=0;i<pathcount;i++) {
-    jstring path = (jstring) (*env)->GetObjectArrayElement(env,oalPaths, i);
-    const char *path_str = (*env)->GetStringUTFChars(env,path, NULL);
-//#ifdef _DEBUG
-    printf("LoadOpenAL: Test 2 loading '%s'\n", path_str);
-//#endif  
+static int LoadOpenAL(JNIEnv *env, jobjectArray oalPaths) {
+
+	jsize pathcount = (*env)->GetArrayLength(env,oalPaths);
+#ifdef _DEBUG
+	printf("Found %d OpenAL paths\n", (int)pathcount);
+#endif	
+    int i;
+	for(i=0;i<pathcount;i++) {
+		jstring path = (jstring) (*env)->GetObjectArrayElement(env,oalPaths, i);
+		const char *path_str = (*env)->GetStringUTFChars(env,path, NULL);
+#ifdef _DEBUG
+		printf("Testing '%s'\n", path_str);
+#endif	
 #ifdef _WIN32
-    handleOAL = LoadLibrary(path_str);
+		handleOAL = LoadLibrary(path_str);
 #endif
 #ifdef _X11
-    handleOAL = dlopen(path_str, RTLD_LAZY);
+		handleOAL = dlopen(path_str, RTLD_LAZY);
 #endif
-    if (handleOAL != NULL) {
-//#ifdef _DEBUG
-      printf("loadOpenAL: Test 3 Found OpenAL at '%s'\n", path_str);
-//#endif  
-      break;
-    }
-    (*env)->ReleaseStringUTFChars(env, path, path_str);
-  }
+#ifdef _AGL
+		handleOAL = NSAddImage(path_str, NSADDIMAGE_OPTION_RETURN_ON_ERROR);
+#endif
+		if (handleOAL != NULL) {
+#ifdef _DEBUG
+			printf("Found OpenAL at '%s'\n", path_str);
+#endif	
+			return 1;
+		}
+		(*env)->ReleaseStringUTFChars(env,path, path_str);
+	}
+	throwOpenALException(env, "Could not load openal library.");
+	return 0;
 }
 
 /**
  * Unloads the OpenAL Library
  */
-void UnLoadOpenAL() {
+static void UnLoadOpenAL() {
 #ifdef _WIN32
-  FreeLibrary(handleOAL);
+	FreeLibrary(handleOAL);
 #endif
 #ifdef _X11
-  dlclose(handleOAL);
+	dlclose(handleOAL);
+#endif
+#ifdef _AGL
+	// Cannot remove the image
 #endif
 }
 
 /**
  * Initializes OpenAL by loading the library
  */
-int InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths) {
-	printf("InitializeOpenAL: Enter\n");
-  if(handleOAL != 0) {
-    return JNI_TRUE;
-  }
-	printf("InitializeOpenAL: test 1\n");	
-  //load our library
-  LoadOpenAL(env, oalPaths);
-	printf("InitializeOpenAL: test 2 handleOAL = %i\n",(int)handleOAL);
-  // if we couldn't load the library, get out
-  if(handleOAL == 0) {
-    return JNI_FALSE;
-  }
-  	printf("InitializeOpenAL: test 3\n");
-  
-  //load basic OpenAL functions
-  if(!LoadAL()) {
-    return JNI_FALSE;
-  }
-  	printf("InitializeOpenAL: test 4\n");
+void InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths) {
+	if(handleOAL != NULL) {
+		return;
+	}
 
-  //load OpenAL context functions
-  if(!LoadALC()) {
-    return JNI_FALSE;
-  }
-  	printf("InitializeOpenAL: test 5\n");
-  //load OpenAL extensions
-  if(!LoadALExtensions()) {
-    return JNI_FALSE;
-  }
-	printf("InitializeOpenAL: Exit\n");
-  return JNI_TRUE;
+	//load our library
+	if (!LoadOpenAL(env, oalPaths)) {
+		return;
+	}
+
+	//load basic OpenAL functions
+	if(!LoadAL()) {
+		throwOpenALException(env, "Could not load OpenAL function pointers.");
+		return;
+	}
+
+	//load OpenAL context functions
+	if(!LoadALC()) {
+		throwOpenALException(env, "Could not load ALC function pointers.");
+		return;
+	}
+
+	//load OpenAL extensions
+	if(!LoadALExtensions()) {
+		throwOpenALException(env, "Could not load AL extension function pointers.");
+		return;
+	}
 }
 
 /**
  * Called to deinitialize OpenAL
  */
 void DeInitializeOpenAL() {
-  UnLoadOpenAL();
-  handleOAL = 0;
+	UnLoadOpenAL();
+	handleOAL = 0;
 }
 
 /**
@@ -254,124 +286,119 @@ void DeInitializeOpenAL() {
  *
  * @return true if all methods were loaded, false if one of the methods could not be loaded
  */
-int LoadAL() {
-  printf("LoadAL: Enter\n");
-  
-  alEnable = (alEnablePROC) GetFunctionPointer("alEnable");
-  alDisable = (alDisablePROC) GetFunctionPointer("alDisable");
-  alIsEnabled = (alIsEnabledPROC) GetFunctionPointer("alIsEnabled");
-  //alHint = (alHintPROC) GetFunctionPointer("alHint");
-  alGetBoolean = (alGetBooleanPROC) GetFunctionPointer("alGetBoolean");
-  alGetInteger = (alGetIntegerPROC) GetFunctionPointer("alGetInteger");
-  alGetFloat = (alGetFloatPROC) GetFunctionPointer("alGetFloat");
-  alGetDouble = (alGetDoublePROC) GetFunctionPointer("alGetDouble");
-  alGetBooleanv = (alGetBooleanvPROC) GetFunctionPointer("alGetBooleanv");
-  alGetIntegerv = (alGetIntegervPROC) GetFunctionPointer("alGetIntegerv");
-  alGetFloatv = (alGetFloatvPROC) GetFunctionPointer("alGetFloatv");
-  alGetDoublev = (alGetDoublevPROC) GetFunctionPointer("alGetDoublev");
-  alGetString = (alGetStringPROC) GetFunctionPointer("alGetString");
-  alGetError = (alGetErrorPROC) GetFunctionPointer("alGetError");
-  alIsExtensionPresent = (alIsExtensionPresentPROC) GetFunctionPointer("alIsExtensionPresent");
-  alGetProcAddress = (alGetProcAddressPROC) GetFunctionPointer("alGetProcAddress");
-  alGetEnumValue = (alGetEnumValuePROC) GetFunctionPointer("alGetEnumValue");
-  alListeneri = (alListeneriPROC) GetFunctionPointer("alListeneri");
-  alListenerf = (alListenerfPROC) GetFunctionPointer("alListenerf");
-  alListener3f = (alListener3fPROC) GetFunctionPointer("alListener3f");
-  alListenerfv = (alListenerfvPROC) GetFunctionPointer("alListenerfv");
-  alGetListeneri = (alGetListeneriPROC) GetFunctionPointer("alGetListeneri");
-  alGetListenerf = (alGetListenerfPROC) GetFunctionPointer("alGetListenerf");
-  alGetListener3f = (alGetListener3fPROC) GetFunctionPointer("alGetListener3f");
-  alGetListenerfv = (alGetListenerfvPROC) GetFunctionPointer("alGetListenerfv");
-  alGenSources = (alGenSourcesPROC) GetFunctionPointer("alGenSources");
-  alDeleteSources = (alDeleteSourcesPROC) GetFunctionPointer("alDeleteSources");
-  alIsSource = (alIsSourcePROC) GetFunctionPointer("alIsSource");
-  alSourcei = (alSourceiPROC) GetFunctionPointer("alSourcei");
-  alSourcef = (alSourcefPROC) GetFunctionPointer("alSourcef");
-  alSource3f = (alSource3fPROC) GetFunctionPointer("alSource3f");
-  alSourcefv = (alSourcefvPROC) GetFunctionPointer("alSourcefv");
-  alGetSourcei = (alGetSourceiPROC) GetFunctionPointer("alGetSourcei");
-  alGetSourcef = (alGetSourcefPROC) GetFunctionPointer("alGetSourcef");
-  alGetSource3f = (alGetSource3fPROC) GetFunctionPointer("alGetSource3f");
-  alGetSourcefv = (alGetSourcefvPROC) GetFunctionPointer("alGetSourcefv");
-  alSourcePlayv = (alSourcePlayvPROC) GetFunctionPointer("alSourcePlayv");
-  alSourcePausev = (alSourcePausevPROC) GetFunctionPointer("alSourcePausev");
-  alSourceStopv = (alSourceStopvPROC) GetFunctionPointer("alSourceStopv");
-  alSourceRewindv = (alSourceRewindvPROC) GetFunctionPointer("alSourceRewindv");
-  alSourcePlay = (alSourcePlayPROC) GetFunctionPointer("alSourcePlay");
-  alSourcePause = (alSourcePausePROC) GetFunctionPointer("alSourcePause");
-  alSourceStop = (alSourceStopPROC) GetFunctionPointer("alSourceStop");
-  alSourceRewind = (alSourceRewindPROC) GetFunctionPointer("alSourceRewind");
-  alGenBuffers = (alGenBuffersPROC) GetFunctionPointer("alGenBuffers");
-  alDeleteBuffers = (alDeleteBuffersPROC) GetFunctionPointer("alDeleteBuffers");
-  alIsBuffer = (alIsBufferPROC) GetFunctionPointer("alIsBuffer");
-  alBufferData = (alBufferDataPROC) GetFunctionPointer("alBufferData");
-  alGetBufferi = (alGetBufferiPROC) GetFunctionPointer("alGetBufferi");
-  alGetBufferf = (alGetBufferfPROC) GetFunctionPointer("alGetBufferf");
-  alSourceQueueBuffers = (alSourceQueueBuffersPROC) GetFunctionPointer("alSourceQueueBuffers");
-  alSourceUnqueueBuffers = (alSourceUnqueueBuffersPROC) GetFunctionPointer("alSourceUnqueueBuffers");
-  alDistanceModel = (alDistanceModelPROC) GetFunctionPointer("alDistanceModel");
-  alDopplerFactor = (alDopplerFactorPROC) GetFunctionPointer("alDopplerFactor");
-  alDopplerVelocity = (alDopplerVelocityPROC) GetFunctionPointer("alDopplerVelocity");
+static int LoadAL() {
+	alEnable = (alEnablePROC) GetFunctionPointer("alEnable");
+	alDisable = (alDisablePROC) GetFunctionPointer("alDisable");
+	alIsEnabled = (alIsEnabledPROC) GetFunctionPointer("alIsEnabled");
+	//alHint = (alHintPROC) GetFunctionPointer("alHint");
+	//alGetintean = (alGetinteanPROC) GetFunctionPointer("alGetintean");
+	alGetInteger = (alGetIntegerPROC) GetFunctionPointer("alGetInteger");
+	alGetFloat = (alGetFloatPROC) GetFunctionPointer("alGetFloat");
+	alGetDouble = (alGetDoublePROC) GetFunctionPointer("alGetDouble");
+	//alGetinteanv = (alGetinteanvPROC) GetFunctionPointer("alGetinteanv");
+	alGetIntegerv = (alGetIntegervPROC) GetFunctionPointer("alGetIntegerv");
+	alGetFloatv = (alGetFloatvPROC) GetFunctionPointer("alGetFloatv");
+	alGetDoublev = (alGetDoublevPROC) GetFunctionPointer("alGetDoublev");
+	alGetString = (alGetStringPROC) GetFunctionPointer("alGetString");
+	alGetError = (alGetErrorPROC) GetFunctionPointer("alGetError");
+	alIsExtensionPresent = (alIsExtensionPresentPROC) GetFunctionPointer("alIsExtensionPresent");
+	alGetProcAddress = (alGetProcAddressPROC) GetFunctionPointer("alGetProcAddress");
+	alGetEnumValue = (alGetEnumValuePROC) GetFunctionPointer("alGetEnumValue");
+	alListeneri = (alListeneriPROC) GetFunctionPointer("alListeneri");
+	alListenerf = (alListenerfPROC) GetFunctionPointer("alListenerf");
+	alListener3f = (alListener3fPROC) GetFunctionPointer("alListener3f");
+	alListenerfv = (alListenerfvPROC) GetFunctionPointer("alListenerfv");
+	alGetListeneri = (alGetListeneriPROC) GetFunctionPointer("alGetListeneri");
+	alGetListenerf = (alGetListenerfPROC) GetFunctionPointer("alGetListenerf");
+	alGetListener3f = (alGetListener3fPROC) GetFunctionPointer("alGetListener3f");
+	alGetListenerfv = (alGetListenerfvPROC) GetFunctionPointer("alGetListenerfv");
+	alGenSources = (alGenSourcesPROC) GetFunctionPointer("alGenSources");
+	alDeleteSources = (alDeleteSourcesPROC) GetFunctionPointer("alDeleteSources");
+	alIsSource = (alIsSourcePROC) GetFunctionPointer("alIsSource");
+	alSourcei = (alSourceiPROC) GetFunctionPointer("alSourcei");
+	alSourcef = (alSourcefPROC) GetFunctionPointer("alSourcef");
+	alSource3f = (alSource3fPROC) GetFunctionPointer("alSource3f");
+	alSourcefv = (alSourcefvPROC) GetFunctionPointer("alSourcefv");
+	alGetSourcei = (alGetSourceiPROC) GetFunctionPointer("alGetSourcei");
+	alGetSourcef = (alGetSourcefPROC) GetFunctionPointer("alGetSourcef");
+	alGetSource3f = (alGetSource3fPROC) GetFunctionPointer("alGetSource3f");
+	alGetSourcefv = (alGetSourcefvPROC) GetFunctionPointer("alGetSourcefv");
+	alSourcePlayv = (alSourcePlayvPROC) GetFunctionPointer("alSourcePlayv");
+	alSourcePausev = (alSourcePausevPROC) GetFunctionPointer("alSourcePausev");
+	alSourceStopv = (alSourceStopvPROC) GetFunctionPointer("alSourceStopv");
+	alSourceRewindv = (alSourceRewindvPROC) GetFunctionPointer("alSourceRewindv");
+	alSourcePlay = (alSourcePlayPROC) GetFunctionPointer("alSourcePlay");
+	alSourcePause = (alSourcePausePROC) GetFunctionPointer("alSourcePause");
+	alSourceStop = (alSourceStopPROC) GetFunctionPointer("alSourceStop");
+	alSourceRewind = (alSourceRewindPROC) GetFunctionPointer("alSourceRewind");
+	alGenBuffers = (alGenBuffersPROC) GetFunctionPointer("alGenBuffers");
+	alDeleteBuffers = (alDeleteBuffersPROC) GetFunctionPointer("alDeleteBuffers");
+	alIsBuffer = (alIsBufferPROC) GetFunctionPointer("alIsBuffer");
+	alBufferData = (alBufferDataPROC) GetFunctionPointer("alBufferData");
+	alGetBufferi = (alGetBufferiPROC) GetFunctionPointer("alGetBufferi");
+	alGetBufferf = (alGetBufferfPROC) GetFunctionPointer("alGetBufferf");
+	alSourceQueueBuffers = (alSourceQueueBuffersPROC) GetFunctionPointer("alSourceQueueBuffers");
+	alSourceUnqueueBuffers = (alSourceUnqueueBuffersPROC) GetFunctionPointer("alSourceUnqueueBuffers");
+	alDistanceModel = (alDistanceModelPROC) GetFunctionPointer("alDistanceModel");
+	alDopplerFactor = (alDopplerFactorPROC) GetFunctionPointer("alDopplerFactor");
+	alDopplerVelocity = (alDopplerVelocityPROC) GetFunctionPointer("alDopplerVelocity");
 
-  int result = 
-    alEnable != NULL &&
-    alDisable != NULL &&
-    alIsEnabled != NULL &&
-    //alHint != NULL &&
-    alGetBoolean != NULL &&
-    alGetInteger != NULL &&
-    alGetFloat != NULL &&
-    alGetDouble != NULL &&
-    alGetBooleanv != NULL &&
-    alGetIntegerv != NULL &&
-    alGetFloatv != NULL &&
-    alGetDoublev != NULL &&
-    alGetString != NULL &&
-    alGetError != NULL &&
-    alIsExtensionPresent != NULL &&
-    alGetProcAddress != NULL &&
-    alGetEnumValue != NULL &&
-    alListeneri != NULL &&
-    alListenerf != NULL &&
-    alListener3f != NULL &&
-    alListenerfv != NULL &&
-    alGetListeneri != NULL &&
-    alGetListenerf != NULL &&
-    alGetListener3f != NULL &&
-    alGetListenerfv != NULL &&
-    alGenSources != NULL &&
-    alDeleteSources != NULL &&
-    alIsSource != NULL &&
-    alSourcei != NULL &&
-    alSourcef != NULL &&
-    alSource3f != NULL &&
-    alSourcefv != NULL &&
-    alGetSourcei != NULL &&
-    alGetSourcef != NULL &&
-    alGetSource3f != NULL &&
-    alGetSourcefv != NULL &&
-    alSourcePlayv != NULL &&
-    alSourcePausev != NULL &&
-    alSourceStopv != NULL &&
-    alSourceRewindv != NULL &&
-    alSourcePlay != NULL &&
-    alSourcePause != NULL &&
-    alSourceStop != NULL &&
-    alSourceRewind != NULL &&
-    alGenBuffers != NULL &&
-    alDeleteBuffers != NULL &&
-    alIsBuffer != NULL &&
-    alBufferData != NULL &&
-    alGetBufferi != NULL &&
-    alGetBufferf != NULL &&
-    alSourceQueueBuffers != NULL &&
-    alSourceUnqueueBuffers != NULL &&
-    alDistanceModel != NULL &&
-    alDopplerFactor != NULL &&
-    alDopplerVelocity != NULL;
-    printf("LoadAL: test 1 result = %i\n",result);
-    printf("LoadAL: Exit\n");    
-    return result;
+	return 
+		alEnable != NULL &&
+		alDisable != NULL &&
+		alIsEnabled != NULL &&
+		//alHint != NULL &&
+		//alGetintean != NULL &&
+		alGetInteger != NULL &&
+		alGetFloat != NULL &&
+		alGetDouble != NULL &&
+		//alGetinteanv != NULL &&
+		alGetIntegerv != NULL &&
+		alGetFloatv != NULL &&
+		alGetDoublev != NULL &&
+		alGetString != NULL &&
+		alGetError != NULL &&
+		alIsExtensionPresent != NULL &&
+		alGetProcAddress != NULL &&
+		alGetEnumValue != NULL &&
+		alListeneri != NULL &&
+		alListenerf != NULL &&
+		alListener3f != NULL &&
+		alListenerfv != NULL &&
+		alGetListeneri != NULL &&
+		alGetListenerf != NULL &&
+		alGetListener3f != NULL &&
+		alGetListenerfv != NULL &&
+		alGenSources != NULL &&
+		alDeleteSources != NULL &&
+		alIsSource != NULL &&
+		alSourcei != NULL &&
+		alSourcef != NULL &&
+		alSource3f != NULL &&
+		alSourcefv != NULL &&
+		alGetSourcei != NULL &&
+		alGetSourcef != NULL &&
+		alGetSource3f != NULL &&
+		alGetSourcefv != NULL &&
+		alSourcePlayv != NULL &&
+		alSourcePausev != NULL &&
+		alSourceStopv != NULL &&
+		alSourceRewindv != NULL &&
+		alSourcePlay != NULL &&
+		alSourcePause != NULL &&
+		alSourceStop != NULL &&
+		alSourceRewind != NULL &&
+		alGenBuffers != NULL &&
+		alDeleteBuffers != NULL &&
+		alIsBuffer != NULL &&
+		alBufferData != NULL &&
+		alGetBufferi != NULL &&
+		alGetBufferf != NULL &&
+		alSourceQueueBuffers != NULL &&
+		alSourceUnqueueBuffers != NULL &&
+		alDistanceModel != NULL &&
+		alDopplerFactor != NULL &&
+		alDopplerVelocity != NULL;
 }
 
 /**
@@ -379,45 +406,39 @@ int LoadAL() {
  *
  * @return true if all methods were loaded, false if one of the methods could not be loaded
  */
-int LoadALC() {
-  printf("LoadALC: Enter\n");
+static int LoadALC() {
+	alcGetString						= (alcGetStringPROC) GetFunctionPointer("alcGetString");
+	alcGetIntegerv					= (alcGetIntegervPROC) GetFunctionPointer("alcGetIntegerv");
+	alcOpenDevice					 = (alcOpenDevicePROC) GetFunctionPointer("alcOpenDevice");
+	alcCloseDevice					= (alcCloseDevicePROC) GetFunctionPointer("alcCloseDevice");
+	alcCreateContext				= (alcCreateContextPROC) GetFunctionPointer("alcCreateContext");
+	alcMakeContextCurrent	 = (alcMakeContextCurrentPROC) GetFunctionPointer("alcMakeContextCurrent");
+	alcProcessContext			 = (alcProcessContextPROC) GetFunctionPointer("alcProcessContext");
+	alcGetCurrentContext		= (alcGetCurrentContextPROC) GetFunctionPointer("alcGetCurrentContext");
+	alcGetContextsDevice		= (alcGetContextsDevicePROC) GetFunctionPointer("alcGetContextsDevice");
+	alcSuspendContext			 = (alcSuspendContextPROC) GetFunctionPointer("alcSuspendContext");
+	alcDestroyContext			 = (alcDestroyContextPROC) GetFunctionPointer("alcDestroyContext");
+	alcGetError						 = (alcGetErrorPROC) GetFunctionPointer("alcGetError");
+	alcIsExtensionPresent	 = (alcIsExtensionPresentPROC) GetFunctionPointer("alcIsExtensionPresent");
+	alcGetProcAddress			 = (alcGetProcAddressPROC) GetFunctionPointer("alcGetProcAddress");
+	alcGetEnumValue				 = (alcGetEnumValuePROC) GetFunctionPointer("alcGetEnumValue");
 
-  alcGetString            = (alcGetStringPROC) GetFunctionPointer("alcGetString");
-  alcGetIntegerv          = (alcGetIntegervPROC) GetFunctionPointer("alcGetIntegerv");
-  alcOpenDevice           = (alcOpenDevicePROC) GetFunctionPointer("alcOpenDevice");
-  alcCloseDevice          = (alcCloseDevicePROC) GetFunctionPointer("alcCloseDevice");
-  alcCreateContext        = (alcCreateContextPROC) GetFunctionPointer("alcCreateContext");
-  alcMakeContextCurrent   = (alcMakeContextCurrentPROC) GetFunctionPointer("alcMakeContextCurrent");
-  alcProcessContext       = (alcProcessContextPROC) GetFunctionPointer("alcProcessContext");
-  alcGetCurrentContext    = (alcGetCurrentContextPROC) GetFunctionPointer("alcGetCurrentContext");
-  alcGetContextsDevice    = (alcGetContextsDevicePROC) GetFunctionPointer("alcGetContextsDevice");
-  alcSuspendContext       = (alcSuspendContextPROC) GetFunctionPointer("alcSuspendContext");
-  alcDestroyContext       = (alcDestroyContextPROC) GetFunctionPointer("alcDestroyContext");
-  alcGetError             = (alcGetErrorPROC) GetFunctionPointer("alcGetError");
-  alcIsExtensionPresent   = (alcIsExtensionPresentPROC) GetFunctionPointer("alcIsExtensionPresent");
-  alcGetProcAddress       = (alcGetProcAddressPROC) GetFunctionPointer("alcGetProcAddress");
-  alcGetEnumValue         = (alcGetEnumValuePROC) GetFunctionPointer("alcGetEnumValue");
-
-  int result = 
-    alcGetString != NULL &&
-    alcGetIntegerv != NULL &&
-    alcOpenDevice != NULL &&
-    alcCloseDevice != NULL &&
-    alcCreateContext != NULL &&
-    alcMakeContextCurrent != NULL &&
-    alcProcessContext != NULL &&
-    alcGetCurrentContext != NULL &&
-    alcGetContextsDevice != NULL &&
-    alcSuspendContext != NULL &&
-    alcDestroyContext != NULL &&
-    alcGetError != NULL &&
-    alcIsExtensionPresent != NULL &&
-    alcGetProcAddress != NULL &&
-    alcGetEnumValue != NULL;
-  
-  printf("LoadALC: test1 result = %i\n",result);
-  printf("LoadALC: Exit\n");
-  return result;
+	return	
+		alcGetString != NULL &&
+		alcGetIntegerv != NULL &&
+		alcOpenDevice != NULL &&
+		alcCloseDevice != NULL &&
+		alcCreateContext != NULL &&
+		alcMakeContextCurrent != NULL &&
+		alcProcessContext != NULL &&
+		alcGetCurrentContext != NULL &&
+		alcGetContextsDevice != NULL &&
+		alcSuspendContext != NULL &&
+		alcDestroyContext != NULL &&
+		alcGetError != NULL &&
+		alcIsExtensionPresent != NULL &&
+		alcGetProcAddress != NULL &&
+		alcGetEnumValue != NULL;
 }
 
 /**
@@ -425,7 +446,6 @@ int LoadALC() {
  *
  * @return true if all methods were loaded, false if one of the methods could not be loaded
  */
-int LoadALExtensions() {
-  return JNI_TRUE;
+static int LoadALExtensions() {
+	return 1;
 }
-
diff --git a/src/native/extal.h b/src/native/extal.h
index ae84ac8..361c2d7 100644
--- a/src/native/extal.h
+++ b/src/native/extal.h
@@ -30,14 +30,26 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _EXTAL_H
-#define _EXTAL_H
+#ifndef _AL_TEST_H
+#define _AL_TEST_H
 
 #ifdef _WIN32
-#include <windows.h>
+#include "windows.h"
 #endif
-#include <altypes.h>
-#include <alctypes.h>
+
+#ifdef _X11
+#include "AL/altypes.h"
+#include "AL/alctypes.h"
+#endif
+#ifdef _WIN32
+#include "altypes.h"
+#include "alctypes.h"
+#endif
+#ifdef _AGL
+#include "OpenAL/alctypes.h"
+#include "OpenAL/altypes.h"
+#endif
+
 #include <jni.h>
 
 #ifdef __cplusplus
@@ -56,10 +68,11 @@ extern "C" {
 
  #define ALCAPIENTRY __cdecl
 #else
- #ifdef TARGET_OS_MAC
-  #if TARGET_OS_MAC
+ #ifdef _AGL
+  #if _AGL
+ typedef struct ALCdevice_struct ALCdevice;
+ typedef struct ALCcontext_struct ALCcontext;
  
-   #pragma export on
   #endif
  #endif
  #define ALCAPI
@@ -109,31 +122,12 @@ typedef void ALCvoid;
  #define ALAPIENTRY __cdecl
  #define AL_CALLBACK
 #else
- #ifdef TARGET_OS_MAC
-  #if TARGET_OS_MAC
-   #pragma export on
-  #endif
- #endif
  #define ALAPI
  #define ALAPIENTRY
  #define AL_CALLBACK
 #endif
-#define INITGUID
-#define OPENAL
 
 #ifdef _WIN32
-/*
-* EAX 2.0 listener property set {0306A6A8-B224-11d2-99E5-0000E8D8C722}
-*/
-/*
-const GUID DSPROPSETID_EAX20_ListenerProperties
-				= { 0x306a6a8, 0xb224, 0x11d2, { 0x99, 0xe5, 0x0, 0x0, 0xe8, 0xd8, 0xc7, 0x22 } };
-
-const GUID DSPROPSETID_EAX20_BufferProperties
-				= { 0x306a6a7, 0xb224, 0x11d2, {0x99, 0xe5, 0x0, 0x0, 0xe8, 0xd8, 0xc7, 0x22 } };
-*/
-#endif
-/*
 DEFINE_GUID(DSPROPSETID_EAX20_ListenerProperties, 
     0x306a6a8, 
     0xb224, 
@@ -144,11 +138,14 @@ DEFINE_GUID(DSPROPSETID_EAX20_BufferProperties,
     0x306a6a7, 
     0xb224, 
     0x11d2, 
-    0x99, 0xe5, 0x0, 0x0, 0xe8, 0xd8, 0xc7, 0x22);    
-*/
-void DeInitializeOpenAL();
+    0x99, 0xe5, 0x0, 0x0, 0xe8, 0xd8, 0xc7, 0x22);
+#endif
 
-int InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths);
+#define INITGUID
+#define OPENAL
+
+void InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths);
+void DeInitializeOpenAL();
 
 //alc
 typedef ALCubyte*   (ALCAPIENTRY *alcGetStringPROC)(ALCdevice *device,ALCenum param);
@@ -313,3 +310,4 @@ extern EAXGet  eaxGet;
 #endif
 
 #endif
+