Name: winePatchDemacroizedOpenALThunk
ChangeLog: Demacroized OpenAL32.dll thunk
GenDate: 2007/01/01 07:14:32 UTC
ModifiedFiles: configure.ac Makefile.in dlls/Makefile.in include/config.h.in
AddedFiles: dlls/openal32/openal.c dlls/openal32/Makefile.in dlls/openal32/openal32.spec
Index: configure.ac
===================================================================
RCS file: /home/wine/wine/configure.ac,v
retrieving revision 1.595
diff -u -r1.595 configure.ac
--- configure.ac	29 Dec 2006 20:36:58 -0000	1.595
+++ configure.ac	1 Jan 2007 07:14:20 -0000
@@ -154,11 +154,14 @@
 AC_SUBST(OPENGLFILES,"")
 AC_SUBST(GLU32FILES,"")
 AC_SUBST(OPENGL_LIBS,"")
+AC_SUBST(OPENAL,"")
 AC_SUBST(QUARTZFILES,"")
 
 dnl **** Check for header files ****
 
 AC_CHECK_HEADERS(\
+	OpenAL/al.h \
+	AL/al.h \
 	AudioUnit/AudioUnit.h \
 	Carbon/Carbon.h \
 	CoreAudio/CoreAudio.h \
@@ -874,6 +877,15 @@
     AC_CHECK_LIB(capi20,capi20_register,[AC_DEFINE(HAVE_CAPI4LINUX,1,[Define if you have capi4linux libs and headers])])
 fi
 
+dnl **** Check for OpenAL support ****
+dnl **** Mac OSX OpenAL support checked below ****
+
+if test "$ac_cv_header_AL_al_h" = "yes"
+	then
+	dnl OpenAL framework
+	AC_SUBST(OPENAL,"-lopenal")
+fi
+
 dnl **** Check for gcc specific options ****
 
 AC_SUBST(EXTRACFLAGS,"")
@@ -1025,6 +1037,11 @@
         dnl CoreServices needed by AudioUnit
         AC_SUBST(COREAUDIO,"-framework CoreAudio -framework AudioUnit -framework CoreServices")
     fi
+	if test "$ac_cv_header_OpenAL_al_h" = "yes"
+	then
+		dnl OpenAL framework
+		AC_SUBST(OPENAL,"-framework OpenAL")
+	fi
     case $host_cpu in
       *powerpc*)
         LDDLLFLAGS="$LDDLLFLAGS -read_only_relocs warning"  dnl FIXME
@@ -1679,6 +1696,7 @@
 dlls/oledlg/Makefile
 dlls/olepro32/Makefile
 dlls/olesvr32/Makefile
+dlls/openal32/Makefile
 dlls/opengl32/Makefile
 dlls/powrprof/Makefile
 dlls/psapi/Makefile
Index: Makefile.in
===================================================================
RCS file: /home/wine/wine/Makefile.in,v
retrieving revision 1.199
diff -u -r1.199 Makefile.in
--- Makefile.in	29 Dec 2006 20:36:23 -0000	1.199
+++ Makefile.in	1 Jan 2007 07:14:20 -0000
@@ -310,6 +310,7 @@
 	dlls/oledlg/Makefile \
 	dlls/olepro32/Makefile \
 	dlls/olesvr32/Makefile \
+	dlls/openal32/Makefile \
 	dlls/opengl32/Makefile \
 	dlls/powrprof/Makefile \
 	dlls/psapi/Makefile \
@@ -635,6 +636,7 @@
 dlls/oledlg/Makefile: dlls/oledlg/Makefile.in dlls/Makedll.rules
 dlls/olepro32/Makefile: dlls/olepro32/Makefile.in dlls/Makedll.rules
 dlls/olesvr32/Makefile: dlls/olesvr32/Makefile.in dlls/Makedll.rules
+dlls/openal32/Makefile: dlls/openal32/Makefile.in dlls/Makedll.rules
 dlls/opengl32/Makefile: dlls/opengl32/Makefile.in dlls/Makedll.rules
 dlls/powrprof/Makefile: dlls/powrprof/Makefile.in dlls/Makedll.rules
 dlls/psapi/Makefile: dlls/psapi/Makefile.in dlls/Makedll.rules
Index: dlls/Makefile.in
===================================================================
RCS file: /home/wine/wine/dlls/Makefile.in,v
retrieving revision 1.338
diff -u -r1.338 Makefile.in
--- dlls/Makefile.in	29 Dec 2006 20:36:23 -0000	1.338
+++ dlls/Makefile.in	1 Jan 2007 07:14:21 -0000
@@ -133,6 +133,7 @@
 	oledlg \
 	olepro32 \
 	olesvr32 \
+	openal32 \
 	powrprof \
 	psapi \
 	pstorec \
Index: include/config.h.in
===================================================================
RCS file: /home/wine/wine/include/config.h.in,v
retrieving revision 1.275
diff -u -r1.275 config.h.in
--- include/config.h.in	29 Dec 2006 20:36:58 -0000	1.275
+++ include/config.h.in	1 Jan 2007 07:14:22 -0000
@@ -11,6 +11,9 @@
 /* Define to 1 if you have the <alsa/asoundlib.h> header file. */
 #undef HAVE_ALSA_ASOUNDLIB_H
 
+/* Define to 1 if you have the <AL/al.h> header file. */
+#undef HAVE_AL_AL_H
+
 /* Define to 1 if you have the <arpa/inet.h> header file. */
 #undef HAVE_ARPA_INET_H
 
@@ -489,6 +492,9 @@
 /* Define to 1 if the system has the type `off_t'. */
 #undef HAVE_OFF_T
 
+/* Define to 1 if you have the <OpenAL/al.h> header file. */
+#undef HAVE_OPENAL_AL_H
+
 /* Define if OpenGL is present on the system */
 #undef HAVE_OPENGL
 
--- /dev/null	2006-12-31 23:09:28.000000000 -0800
+++ dlls/openal32/openal.c	2006-12-31 19:42:14.000000000 -0800
@@ -0,0 +1,1638 @@
+/* Written by Nick Burns (adger44@hotmail.com) */
+/* while sick */
+/* now demacroized */
+
+#include "config.h"
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+/* TODO: add alut (from freealut) -- fill out stubs */
+/* TODO: add other openal extensions */
+/* TODO: better 1.1/ext handling -- do not getProcAddress each and every time */
+
+#if defined(HAVE_OPENAL_AL_H)
+    #include <OpenAL/al.h>
+    #include <OpenAL/alc.h>
+#elif defined(HAVE_AL_AL_H)
+    #include <AL/al.h>
+    #include <AL/alc.h>
+#endif
+
+WINE_DEFAULT_DEBUG_CHANNEL(openal);
+
+/* use builtin deprecated alut functions -- warning not always defined -- use freealut if you have build errors with this on */
+#define USE_BUILTIN_ALUT 0
+
+#if defined(HAVE_OPENAL_AL_H) || defined(HAVE_AL_AL_H)
+
+static HMODULE openal32_handle;
+
+ALCcontext * CDECL wine_alcCreateContext(ALCdevice *device, const ALCint* attrlist)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcCreateContext(device, attrlist);
+}
+
+ALCboolean CDECL wine_alcMakeContextCurrent(ALCcontext *context)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcMakeContextCurrent(context);
+}
+
+void CDECL wine_alcProcessContext(ALCcontext *context)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcProcessContext(context);
+}
+
+void CDECL wine_alcSuspendContext(ALCcontext *context)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcSuspendContext(context);
+}
+
+void CDECL wine_alcDestroyContext(ALCcontext *context)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcDestroyContext(context);
+}
+
+ALCcontext * CDECL wine_alcGetCurrentContext(ALCvoid)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcGetCurrentContext();
+}
+
+ALCdevice * CDECL wine_alcGetContextsDevice(ALCcontext *context)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcGetContextsDevice(context);
+}
+
+ALCdevice * CDECL wine_alcOpenDevice(const ALCchar *devicename)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcOpenDevice(devicename);
+}
+
+ALCboolean CDECL wine_alcCloseDevice(ALCdevice *device)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcCloseDevice(device);
+}
+
+ALCenum CDECL wine_alcGetError(ALCdevice *device)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcGetError(device);
+}
+
+ALCboolean CDECL wine_alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcIsExtensionPresent(device, extname);
+}
+
+ALCenum CDECL wine_alcGetEnumValue(ALCdevice *device, const ALCchar *enumname)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcGetEnumValue(device, enumname);
+}
+
+const ALCchar* CDECL wine_alcGetString(ALCdevice *device, ALCenum param)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcGetString(device, param);
+}
+
+void CDECL wine_alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest)
+{
+    TRACE("WINE_ALC_1_0\n");
+    return alcGetIntegerv(device, param, size, dest);
+}
+
+void CDECL wine_alEnable(ALenum capability)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alEnable(capability);
+}
+
+void CDECL wine_alDisable(ALenum capability)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alDisable(capability);
+}
+
+ALboolean CDECL wine_alIsEnabled(ALenum capability)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alIsEnabled(capability);
+}
+
+const ALchar* CDECL wine_alGetString(ALenum param)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetString(param);
+}
+
+void CDECL wine_alGetBooleanv(ALenum param, ALboolean* data)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetBooleanv(param, data);
+}
+
+void CDECL wine_alGetIntegerv(ALenum param, ALint* data)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetIntegerv(param, data);
+}
+
+void CDECL wine_alGetFloatv(ALenum param, ALfloat* data)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetFloatv(param, data);
+}
+
+void CDECL wine_alGetDoublev(ALenum param, ALdouble* data)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetDoublev(param, data);
+}
+
+ALboolean CDECL wine_alGetBoolean(ALenum param)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetBoolean(param);
+}
+
+ALint CDECL wine_alGetInteger(ALenum param)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetInteger(param);
+}
+
+ALfloat CDECL wine_alGetFloat(ALenum param)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetFloat(param);
+}
+
+ALdouble CDECL wine_alGetDouble(ALenum param)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetDouble(param);
+}
+
+ALenum CDECL wine_alGetError(void)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetError();
+}
+
+ALboolean CDECL wine_alIsExtensionPresent(const ALchar* extname)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alIsExtensionPresent(extname);
+}
+
+ALenum CDECL wine_alGetEnumValue(const ALchar* ename)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetEnumValue(ename);
+}
+
+void CDECL wine_alListenerf(ALenum param, ALfloat value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alListenerf(param, value);
+}
+
+void CDECL wine_alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alListener3f(param, value1, value2, value3);
+}
+
+void CDECL wine_alListenerfv(ALenum param, const ALfloat* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alListenerfv(param, values);
+}
+
+void CDECL wine_alListeneri(ALenum param, ALint value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alListeneri(param, value);
+}
+
+void CDECL wine_alGetListenerf(ALenum param, ALfloat* value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetListenerf(param, value);
+}
+
+void CDECL wine_alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetListener3f(param, value1, value2, value3);
+}
+
+void CDECL wine_alGetListenerfv(ALenum param, ALfloat* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetListenerfv(param, values);
+}
+
+void CDECL wine_alGetListeneri(ALenum param, ALint* value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetListeneri(param, value);
+}
+
+void CDECL wine_alGetListeneriv(ALenum param, ALint* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetListeneriv(param, values);
+}
+
+void CDECL wine_alGenSources(ALsizei n, ALuint* sources)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGenSources(n, sources);
+}
+
+void CDECL wine_alDeleteSources(ALsizei n, const ALuint* sources)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alDeleteSources(n, sources);
+}
+
+ALboolean CDECL wine_alIsSource(ALuint sid)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alIsSource(sid);
+}
+
+void CDECL wine_alSourcef(ALuint sid, ALenum param, ALfloat value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcef(sid, param, value);
+}
+
+void CDECL wine_alSource3f(ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSource3f(sid, param, value1, value2, value3);
+}
+
+void CDECL wine_alSourcefv(ALuint sid, ALenum param, const ALfloat* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcefv(sid, param, values);
+}
+
+void CDECL wine_alSourcei(ALuint sid, ALenum param, ALint value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcei(sid, param, value);
+}
+
+void CDECL wine_alGetSourcef(ALuint sid, ALenum param, ALfloat* value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetSourcef(sid, param, value);
+}
+
+void CDECL wine_alGetSource3f(ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetSource3f(sid, param, value1, value2, value3);
+}
+
+void CDECL wine_alGetSourcefv(ALuint sid, ALenum param, ALfloat* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetSourcefv(sid, param, values);
+}
+
+void CDECL wine_alGetSourcei(ALuint sid, ALenum param, ALint* value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetSourcei(sid, param, value);
+}
+
+void CDECL wine_alGetSourceiv(ALuint sid, ALenum param, ALint* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetSourceiv(sid, param, values);
+}
+
+void CDECL wine_alSourcePlayv(ALsizei ns, const ALuint *sids)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcePlayv(ns, sids);
+}
+
+void CDECL wine_alSourceStopv(ALsizei ns, const ALuint *sids)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourceStopv(ns, sids);
+}
+
+void CDECL wine_alSourceRewindv(ALsizei ns, const ALuint *sids)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourceRewindv(ns, sids);
+}
+
+void CDECL wine_alSourcePausev(ALsizei ns, const ALuint *sids)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcePausev(ns, sids);
+}
+
+void CDECL wine_alSourcePlay(ALuint sid)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcePlay(sid);
+}
+
+void CDECL wine_alSourceStop(ALuint sid)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourceStop(sid);
+}
+
+void CDECL wine_alSourceRewind(ALuint sid)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourceRewind(sid);
+}
+
+void CDECL wine_alSourcePause(ALuint sid)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourcePause(sid);
+}
+
+void CDECL wine_alSourceQueueBuffers(ALuint sid, ALsizei numEntries, const ALuint *bids)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourceQueueBuffers(sid, numEntries, bids);
+}
+
+void CDECL wine_alSourceUnqueueBuffers(ALuint sid, ALsizei numEntries, ALuint *bids)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alSourceUnqueueBuffers(sid, numEntries, bids);
+}
+
+void CDECL wine_alGenBuffers(ALsizei n, ALuint* buffers)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGenBuffers(n, buffers);
+}
+
+void CDECL wine_alDeleteBuffers(ALsizei n, const ALuint* buffers)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alDeleteBuffers(n, buffers);
+}
+
+ALboolean CDECL wine_alIsBuffer(ALuint bid)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alIsBuffer(bid);
+}
+
+void CDECL wine_alBufferData(ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alBufferData(bid, format, data, size, freq);
+}
+
+void CDECL wine_alGetBufferf(ALuint bid, ALenum param, ALfloat* value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetBufferf(bid, param, value);
+}
+
+void CDECL wine_alGetBufferfv(ALuint bid, ALenum param, ALfloat* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetBufferfv(bid, param, values);
+}
+
+void CDECL wine_alGetBufferi(ALuint bid, ALenum param, ALint* value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetBufferi(bid, param, value);
+}
+
+void CDECL wine_alGetBufferiv(ALuint bid, ALenum param, ALint* values)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alGetBufferiv(bid, param, values);
+}
+
+void CDECL wine_alDopplerFactor(ALfloat value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alDopplerFactor(value);
+}
+
+void CDECL wine_alDopplerVelocity(ALfloat value)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alDopplerVelocity(value);
+}
+
+void CDECL wine_alDistanceModel(ALenum distanceModel)
+{
+    TRACE("WINE_AL_1_0\n");
+    return alDistanceModel(distanceModel);
+}
+
+typedef ALCdevice *(*talcCaptureOpenDevice)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
+static talcCaptureOpenDevice p_alcCaptureOpenDevice = NULL;
+ALCdevice * CDECL wine_alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize)
+{
+    p_alcCaptureOpenDevice = (talcCaptureOpenDevice)alcGetProcAddress(NULL, "alcCaptureOpenDevice");
+    TRACE("WINE_ALC_1_1\n");
+    return p_alcCaptureOpenDevice(devicename, frequency, format, buffersize);
+}
+
+typedef ALCboolean(*talcCaptureCloseDevice)(ALCdevice *device);
+static talcCaptureCloseDevice p_alcCaptureCloseDevice = NULL;
+ALCboolean CDECL wine_alcCaptureCloseDevice(ALCdevice *device)
+{
+    p_alcCaptureCloseDevice = (talcCaptureCloseDevice)alcGetProcAddress(NULL, "alcCaptureCloseDevice");
+    TRACE("WINE_ALC_1_1\n");
+    return p_alcCaptureCloseDevice(device);
+}
+
+typedef void(*talcCaptureStart)(ALCdevice *device);
+static talcCaptureStart p_alcCaptureStart = NULL;
+void CDECL wine_alcCaptureStart(ALCdevice *device)
+{
+    p_alcCaptureStart = (talcCaptureStart)alcGetProcAddress(NULL, "alcCaptureStart");
+    TRACE("WINE_ALC_1_1\n");
+    return p_alcCaptureStart(device);
+}
+
+typedef void(*talcCaptureStop)(ALCdevice *device);
+static talcCaptureStop p_alcCaptureStop = NULL;
+void CDECL wine_alcCaptureStop(ALCdevice *device)
+{
+    p_alcCaptureStop = (talcCaptureStop)alcGetProcAddress(NULL, "alcCaptureStop");
+    TRACE("WINE_ALC_1_1\n");
+    return p_alcCaptureStop(device);
+}
+
+typedef void(*talcCaptureSamples)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+static talcCaptureSamples p_alcCaptureSamples = NULL;
+void CDECL wine_alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
+{
+    p_alcCaptureSamples = (talcCaptureSamples)alcGetProcAddress(NULL, "alcCaptureSamples");
+    TRACE("WINE_ALC_1_1\n");
+    return p_alcCaptureSamples(device, buffer, samples);
+}
+
+typedef void(*talListener3i)(ALenum param, ALint value1, ALint value2, ALint value3);
+static talListener3i p_alListener3i = NULL;
+void CDECL wine_alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
+{
+    p_alListener3i = (talListener3i)alGetProcAddress("alListener3i");
+    TRACE("WINE_AL_1_1\n");
+    return p_alListener3i(param, value1, value2, value3);
+}
+
+typedef void(*talListeneriv)(ALenum param, const ALint* values);
+static talListeneriv p_alListeneriv = NULL;
+void CDECL wine_alListeneriv(ALenum param, const ALint* values)
+{
+    p_alListeneriv = (talListeneriv)alGetProcAddress("alListeneriv");
+    TRACE("WINE_AL_1_1\n");
+    return p_alListeneriv(param, values);
+}
+
+typedef void(*talGetListener3i)(ALenum param, ALint *value1, ALint *value2, ALint *value3);
+static talGetListener3i p_alGetListener3i = NULL;
+void CDECL wine_alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
+{
+    p_alGetListener3i = (talGetListener3i)alGetProcAddress("alGetListener3i");
+    TRACE("WINE_AL_1_1\n");
+    return p_alGetListener3i(param, value1, value2, value3);
+}
+
+typedef void(*talSource3i)(ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3);
+static talSource3i p_alSource3i = NULL;
+void CDECL wine_alSource3i(ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3)
+{
+    p_alSource3i = (talSource3i)alGetProcAddress("alSource3i");
+    TRACE("WINE_AL_1_1\n");
+    return p_alSource3i(sid, param, value1, value2, value3);
+}
+
+typedef void(*talSourceiv)(ALuint sid, ALenum param, const ALint* values);
+static talSourceiv p_alSourceiv = NULL;
+void CDECL wine_alSourceiv(ALuint sid, ALenum param, const ALint* values)
+{
+    p_alSourceiv = (talSourceiv)alGetProcAddress("alSourceiv");
+    TRACE("WINE_AL_1_1\n");
+    return p_alSourceiv(sid, param, values);
+}
+
+typedef void(*talGetSource3i)(ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3);
+static talGetSource3i p_alGetSource3i = NULL;
+void CDECL wine_alGetSource3i(ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
+{
+    p_alGetSource3i = (talGetSource3i)alGetProcAddress("alGetSource3i");
+    TRACE("WINE_AL_1_1\n");
+    return p_alGetSource3i(sid, param, value1, value2, value3);
+}
+
+typedef void(*talBufferf)(ALuint bid, ALenum param, ALfloat value);
+static talBufferf p_alBufferf = NULL;
+void CDECL wine_alBufferf(ALuint bid, ALenum param, ALfloat value)
+{
+    p_alBufferf = (talBufferf)alGetProcAddress("alBufferf");
+    TRACE("WINE_AL_1_1\n");
+    return p_alBufferf(bid, param, value);
+}
+
+typedef void(*talBuffer3f)(ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+static talBuffer3f p_alBuffer3f = NULL;
+void CDECL wine_alBuffer3f(ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    p_alBuffer3f = (talBuffer3f)alGetProcAddress("alBuffer3f");
+    TRACE("WINE_AL_1_1\n");
+    return p_alBuffer3f(bid, param, value1, value2, value3);
+}
+
+typedef void(*talBufferfv)(ALuint bid, ALenum param, const ALfloat* values);
+static talBufferfv p_alBufferfv = NULL;
+void CDECL wine_alBufferfv(ALuint bid, ALenum param, const ALfloat* values)
+{
+    p_alBufferfv = (talBufferfv)alGetProcAddress("alBufferfv");
+    TRACE("WINE_AL_1_1\n");
+    return p_alBufferfv(bid, param, values);
+}
+
+typedef void(*talBufferi)(ALuint bid, ALenum param, ALint value);
+static talBufferi p_alBufferi = NULL;
+void CDECL wine_alBufferi(ALuint bid, ALenum param, ALint value)
+{
+    p_alBufferi = (talBufferi)alGetProcAddress("alBufferi");
+    TRACE("WINE_AL_1_1\n");
+    return p_alBufferi(bid, param, value);
+}
+
+typedef void(*talBuffer3i)(ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3);
+static talBuffer3i p_alBuffer3i = NULL;
+void CDECL wine_alBuffer3i(ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3)
+{
+    p_alBuffer3i = (talBuffer3i)alGetProcAddress("alBuffer3i");
+    TRACE("WINE_AL_1_1\n");
+    return p_alBuffer3i(bid, param, value1, value2, value3);
+}
+
+typedef void(*talBufferiv)(ALuint bid, ALenum param, const ALint* values);
+static talBufferiv p_alBufferiv = NULL;
+void CDECL wine_alBufferiv(ALuint bid, ALenum param, const ALint* values)
+{
+    p_alBufferiv = (talBufferiv)alGetProcAddress("alBufferiv");
+    TRACE("WINE_AL_1_1\n");
+    return p_alBufferiv(bid, param, values);
+}
+
+typedef void(*talGetBuffer3f)(ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
+static talGetBuffer3f p_alGetBuffer3f = NULL;
+void CDECL wine_alGetBuffer3f(ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
+{
+    p_alGetBuffer3f = (talGetBuffer3f)alGetProcAddress("alGetBuffer3f");
+    TRACE("WINE_AL_1_1\n");
+    return p_alGetBuffer3f(bid, param, value1, value2, value3);
+}
+
+typedef void(*talGetBuffer3i)(ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3);
+static talGetBuffer3i p_alGetBuffer3i = NULL;
+void CDECL wine_alGetBuffer3i(ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
+{
+    p_alGetBuffer3i = (talGetBuffer3i)alGetProcAddress("alGetBuffer3i");
+    TRACE("WINE_AL_1_1\n");
+    return p_alGetBuffer3i(bid, param, value1, value2, value3);
+}
+
+typedef void(*talSpeedOfSound)(ALfloat value);
+static talSpeedOfSound p_alSpeedOfSound = NULL;
+void CDECL wine_alSpeedOfSound(ALfloat value)
+{
+    p_alSpeedOfSound = (talSpeedOfSound)alGetProcAddress("alSpeedOfSound");
+    TRACE("WINE_AL_1_1\n");
+    return p_alSpeedOfSound(value);
+}
+
+typedef ALvoid(*talcMacOSXRenderingQualityProcPtr)(const ALint value);
+static talcMacOSXRenderingQualityProcPtr p_alcMacOSXRenderingQualityProcPtr = NULL;
+ALvoid CDECL wine_alcMacOSXRenderingQualityProcPtr(const ALint value)
+{
+    p_alcMacOSXRenderingQualityProcPtr = (talcMacOSXRenderingQualityProcPtr)alcGetProcAddress(NULL, "alcMacOSXRenderingQualityProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alcMacOSXRenderingQualityProcPtr(value);
+}
+
+typedef ALvoid(*talMacOSXRenderChannelCountProcPtr)(const ALint value);
+static talMacOSXRenderChannelCountProcPtr p_alMacOSXRenderChannelCountProcPtr = NULL;
+ALvoid CDECL wine_alMacOSXRenderChannelCountProcPtr(const ALint value)
+{
+    p_alMacOSXRenderChannelCountProcPtr = (talMacOSXRenderChannelCountProcPtr)alcGetProcAddress(NULL, "alMacOSXRenderChannelCountProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alMacOSXRenderChannelCountProcPtr(value);
+}
+
+typedef ALvoid(*talcMacOSXMixerMaxiumumBussesProcPtr)(const ALint value);
+static talcMacOSXMixerMaxiumumBussesProcPtr p_alcMacOSXMixerMaxiumumBussesProcPtr = NULL;
+ALvoid CDECL wine_alcMacOSXMixerMaxiumumBussesProcPtr(const ALint value)
+{
+    p_alcMacOSXMixerMaxiumumBussesProcPtr = (talcMacOSXMixerMaxiumumBussesProcPtr)alcGetProcAddress(NULL, "alcMacOSXMixerMaxiumumBussesProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alcMacOSXMixerMaxiumumBussesProcPtr(value);
+}
+
+typedef ALvoid(*talcMacOSXMixerOutputRateProcPtr)(const ALdouble value);
+static talcMacOSXMixerOutputRateProcPtr p_alcMacOSXMixerOutputRateProcPtr = NULL;
+ALvoid CDECL wine_alcMacOSXMixerOutputRateProcPtr(const ALdouble value)
+{
+    p_alcMacOSXMixerOutputRateProcPtr = (talcMacOSXMixerOutputRateProcPtr)alcGetProcAddress(NULL, "alcMacOSXMixerOutputRateProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alcMacOSXMixerOutputRateProcPtr(value);
+}
+
+typedef ALint(*talcMacOSXGetRenderingQualityProcPtr)();
+static talcMacOSXGetRenderingQualityProcPtr p_alcMacOSXGetRenderingQualityProcPtr = NULL;
+ALint CDECL wine_alcMacOSXGetRenderingQualityProcPtr()
+{
+    p_alcMacOSXGetRenderingQualityProcPtr = (talcMacOSXGetRenderingQualityProcPtr)alcGetProcAddress(NULL, "alcMacOSXGetRenderingQualityProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alcMacOSXGetRenderingQualityProcPtr();
+}
+
+typedef ALint(*talMacOSXGetRenderChannelCountProcPtr)();
+static talMacOSXGetRenderChannelCountProcPtr p_alMacOSXGetRenderChannelCountProcPtr = NULL;
+ALint CDECL wine_alMacOSXGetRenderChannelCountProcPtr()
+{
+    p_alMacOSXGetRenderChannelCountProcPtr = (talMacOSXGetRenderChannelCountProcPtr)alcGetProcAddress(NULL, "alMacOSXGetRenderChannelCountProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alMacOSXGetRenderChannelCountProcPtr();
+}
+
+typedef ALint(*talcMacOSXGetMixerMaxiumumBussesProcPtr)();
+static talcMacOSXGetMixerMaxiumumBussesProcPtr p_alcMacOSXGetMixerMaxiumumBussesProcPtr = NULL;
+ALint CDECL wine_alcMacOSXGetMixerMaxiumumBussesProcPtr()
+{
+    p_alcMacOSXGetMixerMaxiumumBussesProcPtr = (talcMacOSXGetMixerMaxiumumBussesProcPtr)alcGetProcAddress(NULL, "alcMacOSXGetMixerMaxiumumBussesProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alcMacOSXGetMixerMaxiumumBussesProcPtr();
+}
+
+typedef ALdouble(*talcMacOSXGetMixerOutputRateProcPtr)();
+static talcMacOSXGetMixerOutputRateProcPtr p_alcMacOSXGetMixerOutputRateProcPtr = NULL;
+ALdouble CDECL wine_alcMacOSXGetMixerOutputRateProcPtr()
+{
+    p_alcMacOSXGetMixerOutputRateProcPtr = (talcMacOSXGetMixerOutputRateProcPtr)alcGetProcAddress(NULL, "alcMacOSXGetMixerOutputRateProcPtr");
+    TRACE("WINE_ALC_EXT_MAC_OSX\n");
+    return p_alcMacOSXGetMixerOutputRateProcPtr();
+}
+
+typedef ALenum(*talcASAGetSourceProcPtr)(const ALuint property, ALuint source, ALvoid *data, ALuint* dataSize);
+static talcASAGetSourceProcPtr p_alcASAGetSourceProcPtr = NULL;
+ALenum CDECL wine_alcASAGetSourceProcPtr(const ALuint property, ALuint source, ALvoid *data, ALuint* dataSize)
+{
+    p_alcASAGetSourceProcPtr = (talcASAGetSourceProcPtr)alcGetProcAddress(NULL, "alcASAGetSourceProcPtr");
+    TRACE("WINE_ALC_EXT_ASA\n");
+    return p_alcASAGetSourceProcPtr(property, source, data, dataSize);
+}
+
+typedef ALenum(*talcASASetSourceProcPtr)(const ALuint property, ALuint source, ALvoid *data, ALuint dataSize);
+static talcASASetSourceProcPtr p_alcASASetSourceProcPtr = NULL;
+ALenum CDECL wine_alcASASetSourceProcPtr(const ALuint property, ALuint source, ALvoid *data, ALuint dataSize)
+{
+    p_alcASASetSourceProcPtr = (talcASASetSourceProcPtr)alcGetProcAddress(NULL, "alcASASetSourceProcPtr");
+    TRACE("WINE_ALC_EXT_ASA\n");
+    return p_alcASASetSourceProcPtr(property, source, data, dataSize);
+}
+
+typedef ALenum(*talcASAGetListenerProcPtr)(const ALuint property, ALvoid *data, ALuint* dataSize);
+static talcASAGetListenerProcPtr p_alcASAGetListenerProcPtr = NULL;
+ALenum CDECL wine_alcASAGetListenerProcPtr(const ALuint property, ALvoid *data, ALuint* dataSize)
+{
+    p_alcASAGetListenerProcPtr = (talcASAGetListenerProcPtr)alcGetProcAddress(NULL, "alcASAGetListenerProcPtr");
+    TRACE("WINE_ALC_EXT_ASA\n");
+    return p_alcASAGetListenerProcPtr(property, data, dataSize);
+}
+
+typedef ALenum(*talcASASetListenerProcPtr)(const ALuint property, ALvoid *data, ALuint dataSize);
+static talcASASetListenerProcPtr p_alcASASetListenerProcPtr = NULL;
+ALenum CDECL wine_alcASASetListenerProcPtr(const ALuint property, ALvoid *data, ALuint dataSize)
+{
+    p_alcASASetListenerProcPtr = (talcASASetListenerProcPtr)alcGetProcAddress(NULL, "alcASASetListenerProcPtr");
+    TRACE("WINE_ALC_EXT_ASA\n");
+    return p_alcASASetListenerProcPtr(property, data, dataSize);
+}
+
+typedef ALvoid(*talBufferDataStatic)(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq);
+static talBufferDataStatic p_alBufferDataStatic = NULL;
+ALvoid CDECL wine_alBufferDataStatic(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq)
+{
+    p_alBufferDataStatic = (talBufferDataStatic)alGetProcAddress("alBufferDataStatic");
+    TRACE("WINE_AL_EXT_STATIC_BUFFER\n");
+    return p_alBufferDataStatic(bid, format, data, size, freq);
+}
+
+typedef ALboolean(*tEAXSetBufferMode)(ALsizei n, ALuint *buffers, ALint value);
+static tEAXSetBufferMode p_EAXSetBufferMode = NULL;
+ALboolean CDECL wine_EAXSetBufferMode(ALsizei n, ALuint *buffers, ALint value)
+{
+    p_EAXSetBufferMode = (tEAXSetBufferMode)alGetProcAddress("EAXSetBufferMode");
+    TRACE("WINE_AL_EXT_EAX_RAM\n");
+    return p_EAXSetBufferMode(n, buffers, value);
+}
+
+typedef ALenum(*tEAXGetBufferMode)(ALuint buffer, ALint *value);
+static tEAXGetBufferMode p_EAXGetBufferMode = NULL;
+ALenum CDECL wine_EAXGetBufferMode(ALuint buffer, ALint *value)
+{
+    p_EAXGetBufferMode = (tEAXGetBufferMode)alGetProcAddress("EAXGetBufferMode");
+    TRACE("WINE_AL_EXT_EAX_RAM\n");
+    return p_EAXGetBufferMode(buffer, value);
+}
+
+typedef void(*talGenEffects)(ALsizei n, ALuint* effects);
+static talGenEffects p_alGenEffects = NULL;
+void CDECL wine_alGenEffects(ALsizei n, ALuint* effects)
+{
+    p_alGenEffects = (talGenEffects)alGetProcAddress("alGenEffects");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGenEffects(n, effects);
+}
+
+typedef void(*talDeleteEffects)(ALsizei n, ALuint* effects);
+static talDeleteEffects p_alDeleteEffects = NULL;
+void CDECL wine_alDeleteEffects(ALsizei n, ALuint* effects)
+{
+    p_alDeleteEffects = (talDeleteEffects)alGetProcAddress("alDeleteEffects");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alDeleteEffects(n, effects);
+}
+
+typedef ALboolean(*talIsEffect)(ALuint eid);
+static talIsEffect p_alIsEffect = NULL;
+ALboolean CDECL wine_alIsEffect(ALuint eid)
+{
+    p_alIsEffect = (talIsEffect)alGetProcAddress("alIsEffect");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alIsEffect(eid);
+}
+
+typedef void(*talEffecti)(ALuint eid, ALenum param, ALint value);
+static talEffecti p_alEffecti = NULL;
+void CDECL wine_alEffecti(ALuint eid, ALenum param, ALint value)
+{
+    p_alEffecti = (talEffecti)alGetProcAddress("alEffecti");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alEffecti(eid, param, value);
+}
+
+typedef void(*talEffectiv)(ALuint eid, ALenum param, ALint* values);
+static talEffectiv p_alEffectiv = NULL;
+void CDECL wine_alEffectiv(ALuint eid, ALenum param, ALint* values)
+{
+    p_alEffectiv = (talEffectiv)alGetProcAddress("alEffectiv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alEffectiv(eid, param, values);
+}
+
+typedef void(*talEffectf)(ALuint eid, ALenum param, ALfloat value);
+static talEffectf p_alEffectf = NULL;
+void CDECL wine_alEffectf(ALuint eid, ALenum param, ALfloat value)
+{
+    p_alEffectf = (talEffectf)alGetProcAddress("alEffectf");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alEffectf(eid, param, value);
+}
+
+typedef void(*talEffectfv)(ALuint eid, ALenum param, ALfloat* values);
+static talEffectfv p_alEffectfv = NULL;
+void CDECL wine_alEffectfv(ALuint eid, ALenum param, ALfloat* values)
+{
+    p_alEffectfv = (talEffectfv)alGetProcAddress("alEffectfv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alEffectfv(eid, param, values);
+}
+
+typedef void(*talGetEffecti)(ALuint eid, ALenum pname, ALint* value);
+static talGetEffecti p_alGetEffecti = NULL;
+void CDECL wine_alGetEffecti(ALuint eid, ALenum pname, ALint* value)
+{
+    p_alGetEffecti = (talGetEffecti)alGetProcAddress("alGetEffecti");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetEffecti(eid, pname, value);
+}
+
+typedef void(*talGetEffectiv)(ALuint eid, ALenum pname, ALint* values);
+static talGetEffectiv p_alGetEffectiv = NULL;
+void CDECL wine_alGetEffectiv(ALuint eid, ALenum pname, ALint* values)
+{
+    p_alGetEffectiv = (talGetEffectiv)alGetProcAddress("alGetEffectiv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetEffectiv(eid, pname, values);
+}
+
+typedef void(*talGetEffectf)(ALuint eid, ALenum pname, ALfloat* value);
+static talGetEffectf p_alGetEffectf = NULL;
+void CDECL wine_alGetEffectf(ALuint eid, ALenum pname, ALfloat* value)
+{
+    p_alGetEffectf = (talGetEffectf)alGetProcAddress("alGetEffectf");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetEffectf(eid, pname, value);
+}
+
+typedef void(*talGetEffectfv)(ALuint eid, ALenum pname, ALfloat* values);
+static talGetEffectfv p_alGetEffectfv = NULL;
+void CDECL wine_alGetEffectfv(ALuint eid, ALenum pname, ALfloat* values)
+{
+    p_alGetEffectfv = (talGetEffectfv)alGetProcAddress("alGetEffectfv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetEffectfv(eid, pname, values);
+}
+
+typedef void(*talGenFilters)(ALsizei n, ALuint* filters);
+static talGenFilters p_alGenFilters = NULL;
+void CDECL wine_alGenFilters(ALsizei n, ALuint* filters)
+{
+    p_alGenFilters = (talGenFilters)alGetProcAddress("alGenFilters");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGenFilters(n, filters);
+}
+
+typedef void(*talDeleteFilters)(ALsizei n, ALuint* filters);
+static talDeleteFilters p_alDeleteFilters = NULL;
+void CDECL wine_alDeleteFilters(ALsizei n, ALuint* filters)
+{
+    p_alDeleteFilters = (talDeleteFilters)alGetProcAddress("alDeleteFilters");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alDeleteFilters(n, filters);
+}
+
+typedef ALboolean(*talIsFilter)(ALuint fid);
+static talIsFilter p_alIsFilter = NULL;
+ALboolean CDECL wine_alIsFilter(ALuint fid)
+{
+    p_alIsFilter = (talIsFilter)alGetProcAddress("alIsFilter");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alIsFilter(fid);
+}
+
+typedef void(*talFilteri)(ALuint fid, ALenum param, ALint value);
+static talFilteri p_alFilteri = NULL;
+void CDECL wine_alFilteri(ALuint fid, ALenum param, ALint value)
+{
+    p_alFilteri = (talFilteri)alGetProcAddress("alFilteri");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alFilteri(fid, param, value);
+}
+
+typedef void(*talFilteriv)(ALuint fid, ALenum param, ALint* values);
+static talFilteriv p_alFilteriv = NULL;
+void CDECL wine_alFilteriv(ALuint fid, ALenum param, ALint* values)
+{
+    p_alFilteriv = (talFilteriv)alGetProcAddress("alFilteriv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alFilteriv(fid, param, values);
+}
+
+typedef void(*talFilterf)(ALuint fid, ALenum param, ALfloat value);
+static talFilterf p_alFilterf = NULL;
+void CDECL wine_alFilterf(ALuint fid, ALenum param, ALfloat value)
+{
+    p_alFilterf = (talFilterf)alGetProcAddress("alFilterf");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alFilterf(fid, param, value);
+}
+
+typedef void(*talFilterfv)(ALuint fid, ALenum param, ALfloat* values);
+static talFilterfv p_alFilterfv = NULL;
+void CDECL wine_alFilterfv(ALuint fid, ALenum param, ALfloat* values)
+{
+    p_alFilterfv = (talFilterfv)alGetProcAddress("alFilterfv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alFilterfv(fid, param, values);
+}
+
+typedef void(*talGetFilteri)(ALuint fid, ALenum pname, ALint* value);
+static talGetFilteri p_alGetFilteri = NULL;
+void CDECL wine_alGetFilteri(ALuint fid, ALenum pname, ALint* value)
+{
+    p_alGetFilteri = (talGetFilteri)alGetProcAddress("alGetFilteri");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetFilteri(fid, pname, value);
+}
+
+typedef void(*talGetFilteriv)(ALuint fid, ALenum pname, ALint* values);
+static talGetFilteriv p_alGetFilteriv = NULL;
+void CDECL wine_alGetFilteriv(ALuint fid, ALenum pname, ALint* values)
+{
+    p_alGetFilteriv = (talGetFilteriv)alGetProcAddress("alGetFilteriv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetFilteriv(fid, pname, values);
+}
+
+typedef void(*talGetFilterf)(ALuint fid, ALenum pname, ALfloat* value);
+static talGetFilterf p_alGetFilterf = NULL;
+void CDECL wine_alGetFilterf(ALuint fid, ALenum pname, ALfloat* value)
+{
+    p_alGetFilterf = (talGetFilterf)alGetProcAddress("alGetFilterf");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetFilterf(fid, pname, value);
+}
+
+typedef void(*talGetFilterfv)(ALuint fid, ALenum pname, ALfloat* values);
+static talGetFilterfv p_alGetFilterfv = NULL;
+void CDECL wine_alGetFilterfv(ALuint fid, ALenum pname, ALfloat* values)
+{
+    p_alGetFilterfv = (talGetFilterfv)alGetProcAddress("alGetFilterfv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetFilterfv(fid, pname, values);
+}
+
+typedef void(*talGenAuxiliaryEffectSlots)(ALsizei n, ALuint* slots);
+static talGenAuxiliaryEffectSlots p_alGenAuxiliaryEffectSlots = NULL;
+void CDECL wine_alGenAuxiliaryEffectSlots(ALsizei n, ALuint* slots)
+{
+    p_alGenAuxiliaryEffectSlots = (talGenAuxiliaryEffectSlots)alGetProcAddress("alGenAuxiliaryEffectSlots");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGenAuxiliaryEffectSlots(n, slots);
+}
+
+typedef void(*talDeleteAuxiliaryEffectSlots)(ALsizei n, ALuint* slots);
+static talDeleteAuxiliaryEffectSlots p_alDeleteAuxiliaryEffectSlots = NULL;
+void CDECL wine_alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint* slots)
+{
+    p_alDeleteAuxiliaryEffectSlots = (talDeleteAuxiliaryEffectSlots)alGetProcAddress("alDeleteAuxiliaryEffectSlots");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alDeleteAuxiliaryEffectSlots(n, slots);
+}
+
+typedef ALboolean(*talIsAuxiliaryEffectSlot)(ALuint slot);
+static talIsAuxiliaryEffectSlot p_alIsAuxiliaryEffectSlot = NULL;
+ALboolean CDECL wine_alIsAuxiliaryEffectSlot(ALuint slot)
+{
+    p_alIsAuxiliaryEffectSlot = (talIsAuxiliaryEffectSlot)alGetProcAddress("alIsAuxiliaryEffectSlot");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alIsAuxiliaryEffectSlot(slot);
+}
+
+typedef void(*talAuxiliaryEffectSloti)(ALuint asid, ALenum param, ALint value);
+static talAuxiliaryEffectSloti p_alAuxiliaryEffectSloti = NULL;
+void CDECL wine_alAuxiliaryEffectSloti(ALuint asid, ALenum param, ALint value)
+{
+    p_alAuxiliaryEffectSloti = (talAuxiliaryEffectSloti)alGetProcAddress("alAuxiliaryEffectSloti");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alAuxiliaryEffectSloti(asid, param, value);
+}
+
+typedef void(*talAuxiliaryEffectSlotiv)(ALuint asid, ALenum param, ALint* values);
+static talAuxiliaryEffectSlotiv p_alAuxiliaryEffectSlotiv = NULL;
+void CDECL wine_alAuxiliaryEffectSlotiv(ALuint asid, ALenum param, ALint* values)
+{
+    p_alAuxiliaryEffectSlotiv = (talAuxiliaryEffectSlotiv)alGetProcAddress("alAuxiliaryEffectSlotiv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alAuxiliaryEffectSlotiv(asid, param, values);
+}
+
+typedef void(*talAuxiliaryEffectSlotf)(ALuint asid, ALenum param, ALfloat value);
+static talAuxiliaryEffectSlotf p_alAuxiliaryEffectSlotf = NULL;
+void CDECL wine_alAuxiliaryEffectSlotf(ALuint asid, ALenum param, ALfloat value)
+{
+    p_alAuxiliaryEffectSlotf = (talAuxiliaryEffectSlotf)alGetProcAddress("alAuxiliaryEffectSlotf");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alAuxiliaryEffectSlotf(asid, param, value);
+}
+
+typedef void(*talAuxiliaryEffectSlotfv)(ALuint asid, ALenum param, ALfloat* values);
+static talAuxiliaryEffectSlotfv p_alAuxiliaryEffectSlotfv = NULL;
+void CDECL wine_alAuxiliaryEffectSlotfv(ALuint asid, ALenum param, ALfloat* values)
+{
+    p_alAuxiliaryEffectSlotfv = (talAuxiliaryEffectSlotfv)alGetProcAddress("alAuxiliaryEffectSlotfv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alAuxiliaryEffectSlotfv(asid, param, values);
+}
+
+typedef void(*talGetAuxiliaryEffectSloti)(ALuint asid, ALenum pname, ALint* value);
+static talGetAuxiliaryEffectSloti p_alGetAuxiliaryEffectSloti = NULL;
+void CDECL wine_alGetAuxiliaryEffectSloti(ALuint asid, ALenum pname, ALint* value)
+{
+    p_alGetAuxiliaryEffectSloti = (talGetAuxiliaryEffectSloti)alGetProcAddress("alGetAuxiliaryEffectSloti");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetAuxiliaryEffectSloti(asid, pname, value);
+}
+
+typedef void(*talGetAuxiliaryEffectSlotiv)(ALuint asid, ALenum pname, ALint* values);
+static talGetAuxiliaryEffectSlotiv p_alGetAuxiliaryEffectSlotiv = NULL;
+void CDECL wine_alGetAuxiliaryEffectSlotiv(ALuint asid, ALenum pname, ALint* values)
+{
+    p_alGetAuxiliaryEffectSlotiv = (talGetAuxiliaryEffectSlotiv)alGetProcAddress("alGetAuxiliaryEffectSlotiv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetAuxiliaryEffectSlotiv(asid, pname, values);
+}
+
+typedef void(*talGetAuxiliaryEffectSlotf)(ALuint asid, ALenum pname, ALfloat* value);
+static talGetAuxiliaryEffectSlotf p_alGetAuxiliaryEffectSlotf = NULL;
+void CDECL wine_alGetAuxiliaryEffectSlotf(ALuint asid, ALenum pname, ALfloat* value)
+{
+    p_alGetAuxiliaryEffectSlotf = (talGetAuxiliaryEffectSlotf)alGetProcAddress("alGetAuxiliaryEffectSlotf");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetAuxiliaryEffectSlotf(asid, pname, value);
+}
+
+typedef void(*talGetAuxiliaryEffectSlotfv)(ALuint asid, ALenum pname, ALfloat* values);
+static talGetAuxiliaryEffectSlotfv p_alGetAuxiliaryEffectSlotfv = NULL;
+void CDECL wine_alGetAuxiliaryEffectSlotfv(ALuint asid, ALenum pname, ALfloat* values)
+{
+    p_alGetAuxiliaryEffectSlotfv = (talGetAuxiliaryEffectSlotfv)alGetProcAddress("alGetAuxiliaryEffectSlotfv");
+    TRACE("WINE_ALC_EXT_EFX\n");
+    return p_alGetAuxiliaryEffectSlotfv(asid, pname, values);
+}
+
+typedef ALenum(*tEAXSet)(const GUID* a, ALuint b, ALuint c, ALvoid* d, ALuint e);
+static tEAXSet p_EAXSet = NULL;
+ALenum CDECL wine_EAXSet(const GUID* a, ALuint b, ALuint c, ALvoid* d, ALuint e)
+{
+    p_EAXSet = (tEAXSet)alGetProcAddress("EAXSet");
+    TRACE("WINE_AL_EXT_EAX2_0\n");
+    return p_EAXSet(a, b, c, d, e);
+}
+
+typedef ALenum(*tEAXGet)(const GUID* a, ALuint b, ALuint c, ALvoid* d, ALuint e);
+static tEAXGet p_EAXGet = NULL;
+ALenum CDECL wine_EAXGet(const GUID* a, ALuint b, ALuint c, ALvoid* d, ALuint e)
+{
+    p_EAXGet = (tEAXGet)alGetProcAddress("EAXGet");
+    TRACE("WINE_AL_EXT_EAX2_0\n");
+    return p_EAXGet(a, b, c, d, e);
+}
+
+#if USE_BUILTIN_ALUT
+
+extern ALvoid alutInit(ALint *argcp, ALbyte **argv);
+ALvoid CDECL wine_alutInit(ALint *argcp, ALbyte **argv)
+{
+    TRACE("WINE_ALUT\n");
+    return alutInit(argcp, argv);
+}
+
+extern ALvoid alutExit(ALvoid);
+ALvoid CDECL wine_alutExit(ALvoid)
+{
+    TRACE("WINE_ALUT\n");
+    return alutExit();
+}
+
+extern ALvoid alutUnloadWAV(ALenum format, ALvoid *data, ALsizei size, ALsizei frequency);
+ALvoid CDECL wine_alutUnloadWAV(ALenum format, ALvoid *data, ALsizei size, ALsizei frequency)
+{
+    TRACE("WINE_ALUT\n");
+    return alutUnloadWAV(format, data, size, frequency);
+}
+
+#if defined(__APPLE__)
+
+/* Incorrectly defined in Mac OSX */
+extern ALvoid alutLoadWAVFile(ALbyte *fileName, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency);
+ALvoid CDECL wine_alutLoadWAVFile(ALbyte *fileName, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop)
+{
+    TRACE("WINE_ALUT\n");
+    if (loop) *loop = AL_FALSE;
+    return alutLoadWAVFile(fileName, format, data, size, frequency);
+}
+
+extern ALvoid alutLoadWAVMemory(ALbyte *buffer, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency);
+ALvoid CDECL wine_alutLoadWAVMemory(ALbyte *buffer, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop)
+{
+    TRACE("WINE_ALUT\n");
+    if (loop) *loop = AL_FALSE;
+    return alutLoadWAVMemory(buffer, format, data, size, frequency);
+}
+
+#else /* !defined(__APPLE__) */
+
+extern ALvoid alutLoadWAVFile(ALbyte *fileName, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop);
+ALvoid CDECL wine_alutLoadWAVFile(ALbyte *fileName, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop)
+{
+    TRACE("WINE_ALUT\n");
+    return alutLoadWAVFile(fileName, format, data, size, frequency, loop);
+}
+
+extern ALvoid alutLoadWAVMemory(ALbyte *buffer, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop);
+ALvoid CDECL wine_alutLoadWAVMemory(ALbyte *buffer, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop)
+{
+    TRACE("WINE_ALUT\n");
+    return alutLoadWAVMemory(buffer, format, data, size, frequency, loop);
+}
+
+#endif /* defined(__APPLE__) */
+
+#else /* !USE_BUILTIN_ALUT */
+
+void CDECL wine_alutInit(ALint *argcp, ALbyte **argv)
+{
+    TRACE("WINE_ALUT\n");
+    FIXME("stub for unimplemented deprecated alut function alutInit\n");
+}
+
+void CDECL wine_alutExit(ALvoid)
+{
+    TRACE("WINE_ALUT\n");
+    FIXME("stub for unimplemented deprecated alut function alutExit\n");
+}
+
+void CDECL wine_alutUnloadWAV(ALenum format, ALvoid *data, ALsizei size, ALsizei frequency)
+{
+    TRACE("WINE_ALUT\n");
+    FIXME("stub for unimplemented deprecated alut function alutUnloadWAV\n");
+}
+
+void CDECL wine_alutLoadWAVFile(ALbyte *fileName, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop)
+{
+    TRACE("WINE_ALUT\n");
+    FIXME("stub for unimplemented deprecated alut function alutLoadWAVFile\n");
+}
+
+void CDECL wine_alutLoadWAVMemory(ALbyte *buffer, ALenum *format, ALvoid **data, ALsizei *size, ALsizei *frequency, ALboolean *loop)
+{
+    TRACE("WINE_ALUT\n");
+    FIXME("stub for unimplemented deprecated alut function alutLoadWAVMemory\n");
+}
+
+#endif /* USE_BUILTIN_ALUT */
+
+void* CDECL wine_alcGetProcAddress(ALCdevice *device, const ALCchar *funcname)
+{
+    void* ret = NULL;
+    TRACE("WINE_ALC_1_0 funcname == %s\n", funcname);
+    /* TODO: maybe check an ext registry/versions? */
+    /*
+        Checks similar to the following could be done...
+        alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE");
+        alcIsExtensionPresent(NULL, "AL_EXT_STATIC_BUFFER");
+    */
+    /* be consistent with the underlying impl */
+    if (alcGetProcAddress(device, funcname))
+    {
+        ret = GetProcAddress(openal32_handle, funcname);
+    }
+    TRACE("funcname == %s, ret == %p\n", funcname, ret);
+    return ret;
+}
+
+void* CDECL wine_alGetProcAddress(const ALchar* fname)
+{
+    void* ret = NULL;
+    TRACE("WINE_AL_1_0 fname == %s\n", fname);
+    /* TODO: maybe check an ext registry/versions? */
+    /*
+        Checks similar to the following could be done...
+        alIsExtensionPresent("ALC_EXT_CAPTURE");
+        alIsExtensionPresent("AL_EXT_STATIC_BUFFER");
+    */
+    /* be consistent with the underlying impl */
+    if (alGetProcAddress(fname))
+    {
+        ret = GetProcAddress(openal32_handle, fname);
+    }
+    TRACE("fname == %s, ret == %p\n", fname, ret);
+    return ret;
+}
+
+/***********************************************************************
+ *           OpenAL initialisation routine
+ */
+BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
+{
+    switch(reason)
+    {
+    case DLL_PROCESS_ATTACH:
+        openal32_handle = hinst;
+        break;
+    case DLL_PROCESS_DETACH:
+        break;
+    }
+    return TRUE;
+}
+
+#else /* !defined(HAVE_OPENAL_AL_H) && !defined(HAVE_AL_AL_H) */
+
+void CDECL wine_alcCreateContext()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcMakeContextCurrent()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcProcessContext()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcSuspendContext()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcDestroyContext()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetCurrentContext()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetContextsDevice()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcOpenDevice()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcCloseDevice()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetError()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcIsExtensionPresent()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetEnumValue()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetString()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetIntegerv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alEnable()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alDisable()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alIsEnabled()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetString()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetBooleanv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetIntegerv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetFloatv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetDoublev()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetBoolean()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetInteger()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetFloat()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetDouble()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetError()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alIsExtensionPresent()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetEnumValue()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alListenerf()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alListener3f()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alListenerfv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alListeneri()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetListenerf()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetListener3f()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetListenerfv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetListeneri()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetListeneriv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGenSources()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alDeleteSources()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alIsSource()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcef()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSource3f()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcefv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcei()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetSourcef()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetSource3f()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetSourcefv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetSourcei()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetSourceiv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcePlayv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourceStopv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourceRewindv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcePausev()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcePlay()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourceStop()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourceRewind()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourcePause()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourceQueueBuffers()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alSourceUnqueueBuffers()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGenBuffers()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alDeleteBuffers()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alIsBuffer()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alBufferData()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetBufferf()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetBufferfv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetBufferi()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetBufferiv()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alDopplerFactor()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alDopplerVelocity()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alDistanceModel()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alutInit()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alutExit()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alutUnloadWAV()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alutLoadWAVFile()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alutLoadWAVMemory()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alcGetProcAddress()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+void CDECL wine_alGetProcAddress()
+{
+    FIXME("OpenAL not supported on this system\n");
+}
+
+/***********************************************************************
+ *           OpenAL initialisation routine
+ */
+BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
+{
+    FIXME("OpenAL not supported on this system\n");
+    return TRUE;
+}
+
+#endif /* defined(HAVE_OPENAL_AL_H) || defined(HAVE_AL_AL_H) */
--- /dev/null	2006-12-31 23:09:28.000000000 -0800
+++ dlls/openal32/Makefile.in	2006-11-20 07:16:28.000000000 -0800
@@ -0,0 +1,14 @@
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR    = @srcdir@
+VPATH     = @srcdir@
+MODULE    = openal32.dll
+IMPORTS   = kernel32 ntdll
+EXTRALIBS = @OPENAL@
+
+C_SRCS = \
+	openal.c
+
+@MAKE_DLL_RULES@
+
+@DEPENDENCIES@  # everything below this line is overwritten by make depend
--- /dev/null	2006-12-31 23:09:28.000000000 -0800
+++ dlls/openal32/openal32.spec	2006-11-20 20:15:36.000000000 -0800
@@ -0,0 +1,133 @@
+#OpenAL ALC_1_0
+@ cdecl alcCreateContext(ptr ptr ) wine_alcCreateContext
+@ cdecl alcMakeContextCurrent(ptr) wine_alcMakeContextCurrent
+@ cdecl alcProcessContext(ptr) wine_alcProcessContext
+@ cdecl alcSuspendContext(ptr) wine_alcSuspendContext
+@ cdecl alcDestroyContext(ptr) wine_alcDestroyContext
+@ cdecl alcGetCurrentContext( ) wine_alcGetCurrentContext
+@ cdecl alcGetContextsDevice(ptr) wine_alcGetContextsDevice
+@ cdecl alcOpenDevice(str) wine_alcOpenDevice
+@ cdecl alcCloseDevice(ptr) wine_alcCloseDevice
+@ cdecl alcGetError(ptr) wine_alcGetError
+@ cdecl alcIsExtensionPresent(ptr str) wine_alcIsExtensionPresent
+@ cdecl alcGetProcAddress(ptr str) wine_alcGetProcAddress
+@ cdecl alcGetEnumValue(ptr str) wine_alcGetEnumValue
+@ cdecl alcGetString(ptr long ) wine_alcGetString
+@ cdecl alcGetIntegerv(ptr long  long  ptr) wine_alcGetIntegerv
+#OpenAL AL_1_0
+@ cdecl alEnable(long ) wine_alEnable
+@ cdecl alDisable(long ) wine_alDisable
+@ cdecl alIsEnabled(long ) wine_alIsEnabled
+@ cdecl alGetString(long ) wine_alGetString
+@ cdecl alGetBooleanv(long  ptr ) wine_alGetBooleanv
+@ cdecl alGetIntegerv(long  ptr ) wine_alGetIntegerv
+@ cdecl alGetFloatv(long  ptr ) wine_alGetFloatv
+@ cdecl alGetDoublev(long  ptr ) wine_alGetDoublev
+@ cdecl alGetBoolean(long ) wine_alGetBoolean
+@ cdecl alGetInteger(long ) wine_alGetInteger
+@ cdecl alGetFloat(long ) wine_alGetFloat
+@ cdecl alGetDouble(long ) wine_alGetDouble
+@ cdecl alGetError( ) wine_alGetError
+@ cdecl alIsExtensionPresent(str ) wine_alIsExtensionPresent
+@ cdecl alGetProcAddress(str ) wine_alGetProcAddress
+@ cdecl alGetEnumValue(str ) wine_alGetEnumValue
+@ cdecl alListenerf(long  long ) wine_alListenerf
+@ cdecl alListener3f(long  long  long  long ) wine_alListener3f
+@ cdecl alListenerfv(long  ptr ) wine_alListenerfv
+@ cdecl alListeneri(long  long ) wine_alListeneri
+@ cdecl alGetListenerf(long  ptr ) wine_alGetListenerf
+@ cdecl alGetListener3f(long  ptr ptr ptr) wine_alGetListener3f
+@ cdecl alGetListenerfv(long  ptr ) wine_alGetListenerfv
+@ cdecl alGetListeneri(long  ptr ) wine_alGetListeneri
+@ cdecl alGetListeneriv(long  ptr ) wine_alGetListeneriv
+@ cdecl alGenSources(long  ptr ) wine_alGenSources
+@ cdecl alDeleteSources(long  ptr ) wine_alDeleteSources
+@ cdecl alIsSource(long ) wine_alIsSource
+@ cdecl alSourcef(long  long  long ) wine_alSourcef
+@ cdecl alSource3f(long  long  long  long  long ) wine_alSource3f
+@ cdecl alSourcefv(long  long  ptr ) wine_alSourcefv
+@ cdecl alSourcei(long  long  long ) wine_alSourcei
+@ cdecl alGetSourcef(long  long  ptr ) wine_alGetSourcef
+@ cdecl alGetSource3f(long  long  ptr  ptr  ptr ) wine_alGetSource3f
+@ cdecl alGetSourcefv(long  long  ptr ) wine_alGetSourcefv
+@ cdecl alGetSourcei(long  long  ptr ) wine_alGetSourcei
+@ cdecl alGetSourceiv(long  long  ptr ) wine_alGetSourceiv
+@ cdecl alSourcePlayv(long  ptr) wine_alSourcePlayv
+@ cdecl alSourceStopv(long  ptr) wine_alSourceStopv
+@ cdecl alSourceRewindv(long  ptr) wine_alSourceRewindv
+@ cdecl alSourcePausev(long  ptr) wine_alSourcePausev
+@ cdecl alSourcePlay(long ) wine_alSourcePlay
+@ cdecl alSourceStop(long ) wine_alSourceStop
+@ cdecl alSourceRewind(long ) wine_alSourceRewind
+@ cdecl alSourcePause(long ) wine_alSourcePause
+@ cdecl alSourceQueueBuffers(long  long  ptr) wine_alSourceQueueBuffers
+@ cdecl alSourceUnqueueBuffers(long  long  ptr) wine_alSourceUnqueueBuffers
+@ cdecl alGenBuffers(long  ptr ) wine_alGenBuffers
+@ cdecl alDeleteBuffers(long  ptr ) wine_alDeleteBuffers
+@ cdecl alIsBuffer(long ) wine_alIsBuffer
+@ cdecl alBufferData(long  long  ptr  long  long ) wine_alBufferData
+@ cdecl alGetBufferf(long  long  ptr ) wine_alGetBufferf
+@ cdecl alGetBufferfv(long  long  ptr ) wine_alGetBufferfv
+@ cdecl alGetBufferi(long  long  ptr ) wine_alGetBufferi
+@ cdecl alGetBufferiv(long  long  ptr ) wine_alGetBufferiv
+@ cdecl alDopplerFactor(long ) wine_alDopplerFactor
+@ cdecl alDopplerVelocity(long ) wine_alDopplerVelocity
+@ cdecl alDistanceModel(long ) wine_alDistanceModel
+#OpenAL ALC_1_1
+#@ cdecl alcCaptureOpenDevice(str long  long  long ) wine_alcCaptureOpenDevice
+#@ cdecl alcCaptureCloseDevice(ptr) wine_alcCaptureCloseDevice
+#@ cdecl alcCaptureStart(ptr) wine_alcCaptureStart
+#@ cdecl alcCaptureStop(ptr) wine_alcCaptureStop
+#@ cdecl alcCaptureSamples(ptr ptr long ) wine_alcCaptureSamples
+#OpenAL AL_1_1
+#@ cdecl alListener3i(long  long  long  long ) wine_alListener3i
+#@ cdecl alListeneriv(long  ptr ) wine_alListeneriv
+#@ cdecl alGetListener3i(long  ptr ptr ptr) wine_alGetListener3i
+#@ cdecl alSource3i(long  long  long  long  long ) wine_alSource3i
+#@ cdecl alSourceiv(long  long  ptr ) wine_alSourceiv
+#@ cdecl alGetSource3i(long  long  ptr  ptr  ptr ) wine_alGetSource3i
+#@ cdecl alBufferf(long  long  long ) wine_alBufferf
+#@ cdecl alBuffer3f(long  long  long  long  long ) wine_alBuffer3f
+#@ cdecl alBufferfv(long  long  ptr ) wine_alBufferfv
+#@ cdecl alBufferi(long  long  long ) wine_alBufferi
+#@ cdecl alBuffer3i(long  long  long  long  long ) wine_alBuffer3i
+#@ cdecl alBufferiv(long  long  ptr ) wine_alBufferiv
+#@ cdecl alGetBuffer3f(long  long  ptr  ptr  ptr ) wine_alGetBuffer3f
+#@ cdecl alGetBuffer3i(long  long  ptr  ptr  ptr ) wine_alGetBuffer3i
+#@ cdecl alSpeedOfSound(long ) wine_alSpeedOfSound
+#OpenAL extensions
+#@ cdecl alcMacOSXRenderingQualityProcPtr(long ) wine_alcMacOSXRenderingQualityProcPtr
+#@ cdecl alMacOSXRenderChannelCountProcPtr(long ) wine_alMacOSXRenderChannelCountProcPtr
+#@ cdecl alcMacOSXMixerMaxiumumBussesProcPtr(long ) wine_alcMacOSXMixerMaxiumumBussesProcPtr
+#@ cdecl alcMacOSXMixerOutputRateProcPtr(double ) wine_alcMacOSXMixerOutputRateProcPtr
+#@ cdecl alcMacOSXGetRenderingQualityProcPtr() wine_alcMacOSXGetRenderingQualityProcPtr
+#@ cdecl alMacOSXGetRenderChannelCountProcPtr() wine_alMacOSXGetRenderChannelCountProcPtr
+#@ cdecl alcMacOSXGetMixerMaxiumumBussesProcPtr() wine_alcMacOSXGetMixerMaxiumumBussesProcPtr
+#@ cdecl alcMacOSXGetMixerOutputRateProcPtr() wine_alcMacOSXGetMixerOutputRateProcPtr
+#@ cdecl alBufferDataStatic(long  long  ptr  long  long ) wine_alBufferDataStatic
+#@ cdecl alcASAGetSourceProcPtr(long  long  ptr ptr ) wine_alcASAGetSourceProcPtr
+#@ cdecl alcASASetSourceProcPtr(long  long  ptr long ) wine_alcASASetSourceProcPtr
+#@ cdecl alcASAGetListenerProcPtr(long  ptr ptr ) wine_alcASAGetListenerProcPtr
+#@ cdecl alcASASetListenerProcPtr(long  ptr long ) wine_alcASASetListenerProcPtr
+#OpenAL ALUT -- now part of freealut -- but binary compat requires this section
+@ cdecl alutInit ( ptr  ptr) wine_alutInit 
+@ cdecl alutExit () wine_alutExit 
+@ cdecl alutLoadWAVFile ( ptr  ptr  ptr  ptr  ptr  ptr) wine_alutLoadWAVFile 
+@ cdecl alutLoadWAVMemory ( ptr  ptr  ptr  ptr  ptr  ptr) wine_alutLoadWAVMemory 
+@ cdecl alutUnloadWAV ( long  ptr  long  long) wine_alutUnloadWAV 
+#OpenAL ALUT new
+#@ cdecl alutInitWithoutContext ( ptr  ptr) wine_alutInitWithoutContext 
+#@ cdecl alutGetError () wine_alutGetError 
+#@ cdecl alutGetErrorString ( long) wine_alutGetErrorString 
+#@ cdecl alutCreateBufferFromFile ( ptr) wine_alutCreateBufferFromFile 
+#@ cdecl alutCreateBufferFromFileImage ( ptr  long) wine_alutCreateBufferFromFileImage 
+#@ cdecl alutCreateBufferHelloWorld () wine_alutCreateBufferHelloWorld 
+#@ cdecl alutCreateBufferWaveform ( long  long  long  long) wine_alutCreateBufferWaveform 
+#@ cdecl alutLoadMemoryFromFile ( ptr  ptr  ptr  ptr) wine_alutLoadMemoryFromFile 
+#@ cdecl alutLoadMemoryFromFileImage ( ptr  long  ptr  ptr  ptr) wine_alutLoadMemoryFromFileImage 
+#@ cdecl alutLoadMemoryHelloWorld ( ptr  ptr  ptr) wine_alutLoadMemoryHelloWorld 
+#@ cdecl alutLoadMemoryWaveform ( long  long  long  long  ptr  ptr  ptr) wine_alutLoadMemoryWaveform 
+#@ cdecl alutGetMIMETypes ( long) wine_alutGetMIMETypes 
+#@ cdecl alutGetMajorVersion () wine_alutGetMajorVersion 
+#@ cdecl alutGetMinorVersion () wine_alutGetMinorVersion 
+#@ cdecl alutSleep ( long) wine_alutSleep 
