Initial check-in of project files

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

1 files changed, 416 insertions, 0 deletions

diff --git a/src/native/extal.c b/src/native/extal.c
new file mode 100644
index 0000000..f7998cc
--- /dev/null
+++ b/src/native/extal.c
@@ -0,0 +1,416 @@
+/* 
+ * 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.
+ */
+
+#include <stdio.h>
+#include <jni.h>
+#include "extal.h"
+
+#ifdef _X11
+#include <dlfcn.h>
+#endif
+
+/**
+ * $Id$
+ *
+ * This file contains the AL extension assigning mechanism
+ *
+ * @author Brian Matzon <[email protected]>
+ * @version $Revision$
+ */
+alEnablePROC alEnable = NULL;
+alDisablePROC alDisable = NULL;
+alIsEnabledPROC alIsEnabled = NULL;
+alHintPROC alHint = NULL;
+alGetBooleanPROC alGetBoolean = NULL;
+alGetIntegerPROC alGetInteger = NULL;
+alGetFloatPROC alGetFloat = NULL;
+alGetDoublePROC alGetDouble = NULL;
+alGetBooleanvPROC alGetBooleanv = NULL;
+alGetIntegervPROC alGetIntegerv = NULL;
+alGetFloatvPROC alGetFloatv = NULL;
+alGetDoublevPROC alGetDoublev = NULL;
+alGetStringPROC alGetString = NULL;
+alGetErrorPROC alGetError = NULL;
+alIsExtensionPresentPROC alIsExtensionPresent = NULL;
+alGetProcAddressPROC alGetProcAddress = NULL;
+alGetEnumValuePROC alGetEnumValue = NULL;
+alListeneriPROC alListeneri = NULL;
+alListenerfPROC alListenerf = NULL;
+alListener3fPROC alListener3f = NULL;
+alListenerfvPROC alListenerfv = NULL;
+alGetListeneriPROC alGetListeneri = NULL;
+alGetListenerfPROC alGetListenerf = NULL;
+alGetListener3fPROC alGetListener3f = NULL;
+alGetListenerfvPROC alGetListenerfv = NULL;
+alGenSourcesPROC alGenSources = NULL;
+alDeleteSourcesPROC alDeleteSources = NULL;
+alIsSourcePROC alIsSource = NULL;
+alSourceiPROC alSourcei = NULL;
+alSourcefPROC alSourcef = NULL;
+alSource3fPROC alSource3f = NULL;
+alSourcefvPROC alSourcefv = NULL;
+alGetSourceiPROC alGetSourcei = NULL;
+alGetSourcefPROC alGetSourcef = NULL;
+alGetSource3fPROC alGetSource3f = NULL;
+alGetSourcefvPROC alGetSourcefv = NULL;
+alSourcePlayvPROC alSourcePlayv = NULL;
+alSourcePausevPROC alSourcePausev = NULL;
+alSourceStopvPROC alSourceStopv = NULL;
+alSourceRewindvPROC alSourceRewindv = NULL;
+alSourcePlayPROC alSourcePlay = NULL;
+alSourcePausePROC alSourcePause = NULL;
+alSourceStopPROC alSourceStop = NULL;
+alSourceRewindPROC alSourceRewind = NULL;
+alGenBuffersPROC alGenBuffers = NULL;
+alDeleteBuffersPROC alDeleteBuffers = NULL;
+alIsBufferPROC alIsBuffer = NULL;
+alBufferDataPROC alBufferData = NULL;
+alGetBufferiPROC alGetBufferi = NULL;
+alGetBufferfPROC alGetBufferf = NULL;
+alSourceQueueBuffersPROC alSourceQueueBuffers = NULL;
+alSourceUnqueueBuffersPROC alSourceUnqueueBuffers = NULL;
+alDistanceModelPROC alDistanceModel = NULL;
+alDopplerFactorPROC alDopplerFactor = NULL;
+alDopplerVelocityPROC alDopplerVelocity = NULL;
+alcGetStringPROC alcGetString = NULL;
+alcGetIntegervPROC alcGetIntegerv = NULL;
+alcOpenDevicePROC alcOpenDevice = NULL;
+alcCloseDevicePROC alcCloseDevice = NULL;
+alcCreateContextPROC alcCreateContext = NULL;
+alcMakeContextCurrentPROC alcMakeContextCurrent = NULL;
+alcProcessContextPROC alcProcessContext = NULL;
+alcGetCurrentContextPROC alcGetCurrentContext = NULL;
+alcGetContextsDevicePROC alcGetContextsDevice = NULL;
+alcSuspendContextPROC alcSuspendContext = NULL;
+alcDestroyContextPROC alcDestroyContext = NULL;
+alcGetErrorPROC alcGetError = NULL;
+alcIsExtensionPresentPROC alcIsExtensionPresent = NULL;
+alcGetProcAddressPROC alcGetProcAddress = NULL;
+alcGetEnumValuePROC alcGetEnumValue = NULL;
+
+#ifdef _WIN32
+EAXSet  eaxSet;                                         // EAXSet function, ret$
+EAXGet  eaxGet;                                         // EAXGet function, ret$
+
+/* Handle to OpenAL Library */
+HMODULE handleOAL;
+#else
+void* handleOAL;
+#endif
+
+/* Loads OpenAL */
+void LoadOpenAL();
+
+/* Unloads OpenAL */
+void UnLoadOpenAL();
+
+/* Gets a pointer to the named function */
+void* GetFunctionPointer(const char* function);
+
+/* Loads OpenAL basic functions */
+int LoadAL();
+
+/* Loads OpenAL ALC functions */
+int LoadALC();
+
+/* Loads any extensions to OpenAL */
+int LoadALExtensions();
+
+/**
+ * Retrieves a pointer to the named function
+ *
+ * @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);
+#endif
+}
+
+/**
+ * Loads the OpenAL Library
+ */
+void LoadOpenAL(JNIEnv *env, jobjectArray oalPaths) {
+  jsize pathcount = (*env)->GetArrayLength(env,oalPaths);
+#ifdef _DEBUG
+  printf("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("Testing '%s'\n", path_str);
+#endif  
+#ifdef _WIN32
+    handleOAL = LoadLibrary(path_str);
+#endif
+#ifdef _X11
+    handleOAL = dlopen(path_str, RTLD_LAZY);
+#endif
+    if (handleOAL != NULL) {
+#ifdef _DEBUG
+      printf("Found OpenAL at '%s'\n", path_str);
+#endif  
+      break;
+    }
+    (*env)->ReleaseStringUTFChars(env, path, path_str);
+  }
+}
+
+/**
+ * Unloads the OpenAL Library
+ */
+void UnLoadOpenAL() {
+#ifdef _WIN32
+  FreeLibrary(handleOAL);
+#endif
+#ifdef _X11
+  dlclose(handleOAL);
+#endif
+}
+
+/**
+ * Initializes OpenAL by loading the library
+ */
+int InitializeOpenAL(JNIEnv *env, jobjectArray oalPaths) {
+  if(handleOAL != 0) {
+    return JNI_TRUE;
+  }
+
+  //load our library
+  LoadOpenAL(env, oalPaths);
+
+  // if we couldn't load the library, get out
+  if(handleOAL == 0) {
+    return JNI_FALSE;
+  }
+  
+  //load basic OpenAL functions
+  if(!LoadAL()) {
+    return JNI_FALSE;
+  }
+
+  //load OpenAL context functions
+  if(!LoadALC()) {
+    return JNI_FALSE;
+  }
+
+  //load OpenAL extensions
+  if(!LoadALExtensions()) {
+    return JNI_FALSE;
+  }
+
+  return JNI_TRUE;
+}
+
+/**
+ * Called to deinitialize OpenAL
+ */
+void DeInitializeOpenAL() {
+  UnLoadOpenAL();
+  handleOAL = 0;
+}
+
+/**
+ * Loads the basic OpenAL functions
+ *
+ * @return true if all methods were loaded, false if one of the methods could not be loaded
+ */
+int LoadAL() {
+  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");
+
+  return 
+    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;
+}
+
+/**
+ * Loads the context OpenAL functions
+ *
+ * @return true if all methods were loaded, false if one of the methods could not be loaded
+ */
+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");
+
+  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;
+}
+
+/**
+ * Loads the OpenAL extensions functions
+ *
+ * @return true if all methods were loaded, false if one of the methods could not be loaded
+ */
+int LoadALExtensions() {
+  return JNI_TRUE;
+}
+