/* 
 * 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 "extal.h"

#ifdef _X11
#include <dlfcn.h>
#endif

/**
 * $Id$
 *
 * This file contains the AL extension assigning mechanism
 *
 * @author Brian Matzon <brian@matzon.dk>
 * @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;
#endif
#ifdef _X11
void* handleOAL;
#endif
#ifdef _AGL
#include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h>
OSStatus oalInitEntryPoints (void);
void oalDellocEntryPoints (void);
CFBundleRef handleOAL = NULL;
#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
#ifdef _AGL
    return CFBundleGetFunctionPointerForName (handleOAL,CFStringCreateWithCStringNoCopy (NULL, function, CFStringGetSystemEncoding (), NULL));
#endif 
}

/**
 * Loads the OpenAL Library
 */
void LoadOpenAL(JNIEnv *env, jobjectArray oalPaths) {

	jsize pathcount = env->GetArrayLength(oalPaths);
#ifdef _DEBUG
  printf("Found %d OpenAL paths\n", pathcount);
#endif  
  for(int i=0;i<pathcount;i++) {
    jstring path = (jstring) env->GetObjectArrayElement(oalPaths, i);
    const char *path_str = env->GetStringUTFChars(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
#ifdef _AGL
    // NOTE: This totally ignores the input array! - SWP
    oalInitEntryPoints();
#endif
    if (handleOAL != NULL) {
#ifdef _DEBUG
      printf("Found OpenAL at '%s'\n", path_str);
#endif  
      break;
    }
    env->ReleaseStringUTFChars(path, path_str);
  }
}

/**
 * Unloads the OpenAL Library
 */
void UnLoadOpenAL() {
#ifdef _WIN32
  FreeLibrary(handleOAL);
#endif
#ifdef _X11
  dlclose(handleOAL);
#endif
#ifdef _AGL
    oalDellocEntryPoints();
#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;
}

#ifdef _AGL
// -------------------------
OSStatus oalInitEntryPoints (void)
{
    OSStatus err = noErr;
    const Str255 frameworkName = "\pOpenAL.framework";
    FSRefParam fileRefParam;
    FSRef fileRef;
    CFURLRef bundleURLOpenAL;
    memset(&fileRefParam, 0, sizeof(fileRefParam));
    memset(&fileRef, 0, sizeof(fileRef));
    fileRefParam.ioNamePtr  = frameworkName;
    fileRefParam.newRef = &fileRef;

    // Frameworks directory/folder
    //
    err = FindFolder (kSystemDomain, kFrameworksFolderType, false, &fileRefParam.ioVRefNum, &fileRefParam.ioDirID);
    if (noErr != err)
    {
        DebugStr ("\pCould not find frameworks folder");
        return err;
    }

    // make FSRef for folder
    //
    err = PBMakeFSRefSync (&fileRefParam);


    if (noErr != err)
    {
        DebugStr ("\pCould make FSref to frameworks folder");
        return err;
    }

    // create URL to folder
    //
    bundleURLOpenAL = CFURLCreateFromFSRef (kCFAllocatorDefault, &fileRef);
    if (!bundleURLOpenAL)
    {
        DebugStr ("\pCould create OpenAL Framework bundle URL");
        return paramErr;
    }

    // create ref to GL's bundle
    //
    handleOAL = CFBundleCreate (kCFAllocatorDefault,bundleURLOpenAL);
    if (!handleOAL)
    {
        DebugStr ("\pCould not create OpenAL Framework bundle");
        return paramErr;
    }

    // release created bundle
    //
    CFRelease (bundleURLOpenAL);

    // if the code was successfully loaded, look for our function.
    if (!CFBundleLoadExecutable (handleOAL))
    {
        DebugStr ("\pCould not load OpenAL MachO executable");
        return paramErr;
    }

    return err;
}


void oalDellocEntryPoints (void)
{
    if (handleOAL != NULL)
    {
        // unload the bundle's code.
        CFBundleUnloadExecutable (handleOAL);
        CFRelease (handleOAL);
        handleOAL = NULL;
    }
}

#endif