diff --git a/dlls/openal32/openal.c b/dlls/openal32/openal.c
index b2ee1e99d82edbcc133e44a0e7b93b36ba7d931b..840498d2dc70ab0211ecdc4d8ad2a340be50b9ac 100644
--- a/dlls/openal32/openal.c
+++ b/dlls/openal32/openal.c
@@ -29,9 +29,23 @@
 #include "winbase.h"
 #include "wine/debug.h"
 
+#ifdef HAVE_AL_AL_H
+#include <AL/al.h>
+#include <AL/alc.h>
+#endif
+
 WINE_DEFAULT_DEBUG_CHANNEL(openal32);
 
 
+struct FuncList {
+    const char *name;
+    void *proc;
+};
+
+static const struct FuncList ALCFuncs[];
+static const struct FuncList ALFuncs[];
+
+
 /***********************************************************************
  *           OpenAL initialisation routine
  */
@@ -39,9 +53,616 @@ BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
 {
     switch(reason)
     {
-    case DLL_WINE_PREATTACH:
-        return FALSE; /* prefer native version */
+    case DLL_PROCESS_ATTACH:
+        DisableThreadLibraryCalls(hinst);
+        break;
     }
 
     return TRUE;
 }
+
+
+/***********************************************************************
+ *           OpenAL thunk routines
+ */
+
+/* OpenAL ALC 1.0 functions */
+ALCcontext* CDECL wine_alcCreateContext(ALCdevice *device, const ALCint* attrlist)
+{
+    return alcCreateContext(device, attrlist);
+}
+
+ALCboolean CDECL wine_alcMakeContextCurrent(ALCcontext *context)
+{
+    return alcMakeContextCurrent(context);
+}
+
+ALvoid CDECL wine_alcProcessContext(ALCcontext *context)
+{
+    alcProcessContext(context);
+}
+
+ALvoid CDECL wine_alcSuspendContext(ALCcontext *context)
+{
+    alcSuspendContext(context);
+}
+
+ALvoid CDECL wine_alcDestroyContext(ALCcontext *context)
+{
+    alcDestroyContext(context);
+}
+
+ALCcontext* CDECL wine_alcGetCurrentContext(ALCvoid)
+{
+    return alcGetCurrentContext();
+}
+
+ALCdevice* CDECL wine_alcGetContextsDevice(ALCcontext *context)
+{
+    return alcGetContextsDevice(context);
+}
+
+ALCdevice* CDECL wine_alcOpenDevice(const ALCchar *devicename)
+{
+    return alcOpenDevice(devicename);
+}
+
+ALCboolean CDECL wine_alcCloseDevice(ALCdevice *device)
+{
+    return alcCloseDevice(device);
+}
+
+ALCenum CDECL wine_alcGetError(ALCdevice *device)
+{
+    return alcGetError(device);
+}
+
+ALCboolean CDECL wine_alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname)
+{
+    return alcIsExtensionPresent(device, extname);
+}
+
+ALCvoid* CDECL wine_alcGetProcAddress(ALCdevice *device, const ALCchar *funcname)
+{
+    void *proc;
+    int i;
+
+    /* Make sure the host implementation has the requested function */
+    proc = alcGetProcAddress(device, funcname);
+    if(!proc)
+        return NULL;
+
+    for(i = 0;ALCFuncs[i].name;i++)
+    {
+        if(strcmp(funcname, ALCFuncs[i].name) == 0)
+            return ALCFuncs[i].proc;
+    }
+    FIXME("Could not find function in list: %s\n", funcname);
+    return NULL;
+}
+
+ALCenum CDECL wine_alcGetEnumValue(ALCdevice *device, const ALCchar *enumname)
+{
+    return alcGetEnumValue(device, enumname);
+}
+
+const ALCchar* CDECL wine_alcGetString(ALCdevice *device, ALCenum param)
+{
+    return alcGetString(device, param);
+}
+
+ALvoid CDECL wine_alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest)
+{
+    return alcGetIntegerv(device, param, size, dest);
+}
+
+
+/* OpenAL 1.0 functions */
+ALvoid CDECL wine_alEnable(ALenum capability)
+{
+    alEnable(capability);
+}
+
+ALvoid CDECL wine_alDisable(ALenum capability)
+{
+    alDisable(capability);
+}
+
+ALboolean CDECL wine_alIsEnabled(ALenum capability)
+{
+    return alIsEnabled(capability);
+}
+
+const ALchar* CDECL wine_alGetString(ALenum param)
+{
+    return alGetString(param);
+}
+
+ALvoid CDECL wine_alGetBooleanv(ALenum param, ALboolean* data)
+{
+    alGetBooleanv(param, data);
+}
+
+ALvoid CDECL wine_alGetIntegerv(ALenum param, ALint* data)
+{
+    alGetIntegerv(param, data);
+}
+
+ALvoid CDECL wine_alGetFloatv(ALenum param, ALfloat* data)
+{
+    alGetFloatv(param, data);
+}
+
+ALvoid CDECL wine_alGetDoublev(ALenum param, ALdouble* data)
+{
+    alGetDoublev(param, data);
+}
+
+ALboolean CDECL wine_alGetBoolean(ALenum param)
+{
+    return alGetBoolean(param);
+}
+
+ALint CDECL wine_alGetInteger(ALenum param)
+{
+    return alGetInteger(param);
+}
+
+ALfloat CDECL wine_alGetFloat(ALenum param)
+{
+    return alGetFloat(param);
+}
+
+ALdouble CDECL wine_alGetDouble(ALenum param)
+{
+    return alGetDouble(param);
+}
+
+ALenum CDECL wine_alGetError(ALvoid)
+{
+    return alGetError();
+}
+
+ALboolean CDECL wine_alIsExtensionPresent(const ALchar* extname)
+{
+    return alIsExtensionPresent(extname);
+}
+
+ALvoid* CDECL wine_alGetProcAddress(const ALchar* funcname)
+{
+    void *proc;
+    int i;
+
+    /* Make sure the host implementation has the requested function. This will
+     * also set the last AL error properly if the function should not be
+     * returned (eg. no current context). */
+    proc = alGetProcAddress(funcname);
+    if(!proc)
+        return NULL;
+
+    for(i = 0;ALFuncs[i].name;i++)
+    {
+        if(strcmp(funcname, ALFuncs[i].name) == 0)
+            return ALFuncs[i].proc;
+    }
+    FIXME("Could not find function in list: %s\n", funcname);
+    return NULL;
+}
+
+ALenum CDECL wine_alGetEnumValue(const ALchar* ename)
+{
+    return alGetEnumValue(ename);
+}
+
+ALvoid CDECL wine_alListenerf(ALenum param, ALfloat value)
+{
+    alListenerf(param, value);
+}
+
+ALvoid CDECL wine_alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    alListener3f(param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alListenerfv(ALenum param, const ALfloat* values)
+{
+    alListenerfv(param, values);
+}
+
+ALvoid CDECL wine_alListeneri(ALenum param, ALint value)
+{
+    alListeneri(param, value);
+}
+
+ALvoid CDECL wine_alGetListenerf(ALenum param, ALfloat* value)
+{
+    alGetListenerf(param, value);
+}
+
+ALvoid CDECL wine_alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
+{
+    alGetListener3f(param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alGetListenerfv(ALenum param, ALfloat* values)
+{
+    alGetListenerfv(param, values);
+}
+
+ALvoid CDECL wine_alGetListeneri(ALenum param, ALint* value)
+{
+    alGetListeneri(param, value);
+}
+
+ALvoid CDECL wine_alGetListeneriv(ALenum param, ALint* values)
+{
+    alGetListeneriv(param, values);
+}
+
+ALvoid CDECL wine_alGenSources(ALsizei n, ALuint* sources)
+{
+    alGenSources(n, sources);
+}
+
+ALvoid CDECL wine_alDeleteSources(ALsizei n, const ALuint* sources)
+{
+    alDeleteSources(n, sources);
+}
+
+ALboolean CDECL wine_alIsSource(ALuint sid)
+{
+    return alIsSource(sid);
+}
+
+ALvoid CDECL wine_alSourcef(ALuint sid, ALenum param, ALfloat value)
+{
+    alSourcef(sid, param, value);
+}
+
+ALvoid CDECL wine_alSource3f(ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    alSource3f(sid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alSourcefv(ALuint sid, ALenum param, const ALfloat* values)
+{
+    alSourcefv(sid, param, values);
+}
+
+ALvoid CDECL wine_alSourcei(ALuint sid, ALenum param, ALint value)
+{
+    alSourcei(sid, param, value);
+}
+
+ALvoid CDECL wine_alGetSourcef(ALuint sid, ALenum param, ALfloat* value)
+{
+    alGetSourcef(sid, param, value);
+}
+
+ALvoid CDECL wine_alGetSource3f(ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
+{
+    alGetSource3f(sid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alGetSourcefv(ALuint sid, ALenum param, ALfloat* values)
+{
+    alGetSourcefv(sid, param, values);
+}
+
+ALvoid CDECL wine_alGetSourcei(ALuint sid, ALenum param, ALint* value)
+{
+    alGetSourcei(sid, param, value);
+}
+
+ALvoid CDECL wine_alGetSourceiv(ALuint sid, ALenum param, ALint* values)
+{
+    alGetSourceiv(sid, param, values);
+}
+
+ALvoid CDECL wine_alSourcePlayv(ALsizei ns, const ALuint *sids)
+{
+    alSourcePlayv(ns, sids);
+}
+
+ALvoid CDECL wine_alSourceStopv(ALsizei ns, const ALuint *sids)
+{
+    alSourceStopv(ns, sids);
+}
+
+ALvoid CDECL wine_alSourceRewindv(ALsizei ns, const ALuint *sids)
+{
+    alSourceRewindv(ns, sids);
+}
+
+ALvoid CDECL wine_alSourcePausev(ALsizei ns, const ALuint *sids)
+{
+    alSourcePausev(ns, sids);
+}
+
+ALvoid CDECL wine_alSourcePlay(ALuint sid)
+{
+    alSourcePlay(sid);
+}
+
+ALvoid CDECL wine_alSourceStop(ALuint sid)
+{
+    alSourceStop(sid);
+}
+
+ALvoid CDECL wine_alSourceRewind(ALuint sid)
+{
+    alSourceRewind(sid);
+}
+
+ALvoid CDECL wine_alSourcePause(ALuint sid)
+{
+    alSourcePause(sid);
+}
+
+ALvoid CDECL wine_alSourceQueueBuffers(ALuint sid, ALsizei numEntries, const ALuint *bids)
+{
+    alSourceQueueBuffers(sid, numEntries, bids);
+}
+
+ALvoid CDECL wine_alSourceUnqueueBuffers(ALuint sid, ALsizei numEntries, ALuint *bids)
+{
+    alSourceUnqueueBuffers(sid, numEntries, bids);
+}
+
+ALvoid CDECL wine_alGenBuffers(ALsizei n, ALuint* buffers)
+{
+    alGenBuffers(n, buffers);
+}
+
+ALvoid CDECL wine_alDeleteBuffers(ALsizei n, const ALuint* buffers)
+{
+    alDeleteBuffers(n, buffers);
+}
+
+ALboolean CDECL wine_alIsBuffer(ALuint bid)
+{
+    return alIsBuffer(bid);
+}
+
+ALvoid CDECL wine_alBufferData(ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
+{
+    alBufferData(bid, format, data, size, freq);
+}
+
+ALvoid CDECL wine_alGetBufferf(ALuint bid, ALenum param, ALfloat* value)
+{
+    alGetBufferf(bid, param, value);
+}
+
+ALvoid CDECL wine_alGetBufferfv(ALuint bid, ALenum param, ALfloat* values)
+{
+    alGetBufferfv(bid, param, values);
+}
+
+ALvoid CDECL wine_alGetBufferi(ALuint bid, ALenum param, ALint* value)
+{
+    alGetBufferi(bid, param, value);
+}
+
+ALvoid CDECL wine_alGetBufferiv(ALuint bid, ALenum param, ALint* values)
+{
+    alGetBufferiv(bid, param, values);
+}
+
+ALvoid CDECL wine_alDopplerFactor(ALfloat value)
+{
+    alDopplerFactor(value);
+}
+
+ALvoid CDECL wine_alDopplerVelocity(ALfloat value)
+{
+    alDopplerVelocity(value);
+}
+
+ALvoid CDECL wine_alDistanceModel(ALenum distanceModel)
+{
+    alDistanceModel(distanceModel);
+}
+
+
+/* OpenAL ALC 1.1 functions */
+ALCdevice* CDECL wine_alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize)
+{
+     return alcCaptureOpenDevice(devicename, frequency, format, buffersize);
+}
+
+ALCboolean CDECL wine_alcCaptureCloseDevice(ALCdevice *device)
+{
+    return alcCaptureCloseDevice(device);
+}
+
+ALCvoid CDECL wine_alcCaptureStart(ALCdevice *device)
+{
+    alcCaptureStart(device);
+}
+
+ALCvoid CDECL wine_alcCaptureStop(ALCdevice *device)
+{
+    alcCaptureStop(device);
+}
+
+ALCvoid CDECL wine_alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
+{
+    alcCaptureSamples(device, buffer, samples);
+}
+
+/* OpenAL 1.1 functions */
+ALvoid CDECL wine_alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
+{
+    alListener3i(param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alListeneriv(ALenum param, const ALint* values)
+{
+    alListeneriv(param, values);
+}
+
+ALvoid CDECL wine_alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
+{
+    alGetListener3i(param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alSource3i(ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3)
+{
+    alSource3i(sid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alSourceiv(ALuint sid, ALenum param, const ALint* values)
+{
+    alSourceiv(sid, param, values);
+}
+
+ALvoid CDECL wine_alGetSource3i(ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
+{
+    alGetSource3i(sid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alBufferf(ALuint bid, ALenum param, ALfloat value)
+{
+    alBufferf(bid, param, value);
+}
+
+ALvoid CDECL wine_alBuffer3f(ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    alBuffer3f(bid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alBufferfv(ALuint bid, ALenum param, const ALfloat* values)
+{
+    alBufferfv(bid, param, values);
+}
+
+ALvoid CDECL wine_alBufferi(ALuint bid, ALenum param, ALint value)
+{
+    alBufferi(bid, param, value);
+}
+
+ALvoid CDECL wine_alBuffer3i(ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3)
+{
+    alBuffer3i(bid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alBufferiv(ALuint bid, ALenum param, const ALint* values)
+{
+    alBufferiv(bid, param, values);
+}
+
+ALvoid CDECL wine_alGetBuffer3f(ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
+{
+    alGetBuffer3f(bid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alGetBuffer3i(ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
+{
+    alGetBuffer3i(bid, param, value1, value2, value3);
+}
+
+ALvoid CDECL wine_alSpeedOfSound(ALfloat value)
+{
+    alSpeedOfSound(value);
+}
+
+static const struct FuncList ALCFuncs[] = {
+    { "alcCreateContext",           wine_alcCreateContext        },
+    { "alcMakeContextCurrent",      wine_alcMakeContextCurrent   },
+    { "alcProcessContext",          wine_alcProcessContext       },
+    { "alcSuspendContext",          wine_alcSuspendContext       },
+    { "alcDestroyContext",          wine_alcDestroyContext       },
+    { "alcGetCurrentContext",       wine_alcGetCurrentContext    },
+    { "alcGetContextsDevice",       wine_alcGetContextsDevice    },
+    { "alcOpenDevice",              wine_alcOpenDevice           },
+    { "alcCloseDevice",             wine_alcCloseDevice          },
+    { "alcGetError",                wine_alcGetError             },
+    { "alcIsExtensionPresent",      wine_alcIsExtensionPresent   },
+    { "alcGetProcAddress",          wine_alcGetProcAddress       },
+    { "alcGetEnumValue",            wine_alcGetEnumValue         },
+    { "alcGetString",               wine_alcGetString            },
+    { "alcGetIntegerv",             wine_alcGetIntegerv          },
+    { "alcCaptureOpenDevice",       wine_alcCaptureOpenDevice    },
+    { "alcCaptureCloseDevice",      wine_alcCaptureCloseDevice   },
+    { "alcCaptureStart",            wine_alcCaptureStart         },
+    { "alcCaptureStop",             wine_alcCaptureStop          },
+    { "alcCaptureSamples",          wine_alcCaptureSamples       },
+    { NULL,                         NULL                         }
+};
+static const struct FuncList ALFuncs[] = {
+    { "alEnable",                   wine_alEnable                },
+    { "alDisable",                  wine_alDisable               },
+    { "alIsEnabled",                wine_alIsEnabled             },
+    { "alGetString",                wine_alGetString             },
+    { "alGetBooleanv",              wine_alGetBooleanv           },
+    { "alGetIntegerv",              wine_alGetIntegerv           },
+    { "alGetFloatv",                wine_alGetFloatv             },
+    { "alGetDoublev",               wine_alGetDoublev            },
+    { "alGetBoolean",               wine_alGetBoolean            },
+    { "alGetInteger",               wine_alGetInteger            },
+    { "alGetFloat",                 wine_alGetFloat              },
+    { "alGetDouble",                wine_alGetDouble             },
+    { "alGetError",                 wine_alGetError              },
+    { "alIsExtensionPresent",       wine_alIsExtensionPresent    },
+    { "alGetProcAddress",           wine_alGetProcAddress        },
+    { "alGetEnumValue",             wine_alGetEnumValue          },
+    { "alListenerf",                wine_alListenerf             },
+    { "alListener3f",               wine_alListener3f            },
+    { "alListenerfv",               wine_alListenerfv            },
+    { "alListeneri",                wine_alListeneri             },
+    { "alListener3i",               wine_alListener3i            },
+    { "alListeneriv",               wine_alListeneriv            },
+    { "alGetListenerf",             wine_alGetListenerf          },
+    { "alGetListener3f",            wine_alGetListener3f         },
+    { "alGetListenerfv",            wine_alGetListenerfv         },
+    { "alGetListeneri",             wine_alGetListeneri          },
+    { "alGetListener3i",            wine_alGetListener3i         },
+    { "alGetListeneriv",            wine_alGetListeneriv         },
+    { "alGenSources",               wine_alGenSources            },
+    { "alDeleteSources",            wine_alDeleteSources         },
+    { "alIsSource",                 wine_alIsSource              },
+    { "alSourcef",                  wine_alSourcef               },
+    { "alSource3f",                 wine_alSource3f              },
+    { "alSourcefv",                 wine_alSourcefv              },
+    { "alSourcei",                  wine_alSourcei               },
+    { "alSource3i",                 wine_alSource3i              },
+    { "alSourceiv",                 wine_alSourceiv              },
+    { "alGetSourcef",               wine_alGetSourcef            },
+    { "alGetSource3f",              wine_alGetSource3f           },
+    { "alGetSourcefv",              wine_alGetSourcefv           },
+    { "alGetSourcei",               wine_alGetSourcei            },
+    { "alGetSource3i",              wine_alGetSource3i           },
+    { "alGetSourceiv",              wine_alGetSourceiv           },
+    { "alSourcePlayv",              wine_alSourcePlayv           },
+    { "alSourceStopv",              wine_alSourceStopv           },
+    { "alSourceRewindv",            wine_alSourceRewindv         },
+    { "alSourcePausev",             wine_alSourcePausev          },
+    { "alSourcePlay",               wine_alSourcePlay            },
+    { "alSourceStop",               wine_alSourceStop            },
+    { "alSourceRewind",             wine_alSourceRewind          },
+    { "alSourcePause",              wine_alSourcePause           },
+    { "alSourceQueueBuffers",       wine_alSourceQueueBuffers    },
+    { "alSourceUnqueueBuffers",     wine_alSourceUnqueueBuffers  },
+    { "alGenBuffers",               wine_alGenBuffers            },
+    { "alDeleteBuffers",            wine_alDeleteBuffers         },
+    { "alIsBuffer",                 wine_alIsBuffer              },
+    { "alBufferData",               wine_alBufferData            },
+    { "alBufferf",                  wine_alBufferf               },
+    { "alBuffer3f",                 wine_alBuffer3f              },
+    { "alBufferfv",                 wine_alBufferfv              },
+    { "alBufferi",                  wine_alBufferi               },
+    { "alBuffer3i",                 wine_alBuffer3i              },
+    { "alBufferiv",                 wine_alBufferiv              },
+    { "alGetBufferf",               wine_alGetBufferf            },
+    { "alGetBuffer3f",              wine_alGetBuffer3f           },
+    { "alGetBufferfv",              wine_alGetBufferfv           },
+    { "alGetBufferi",               wine_alGetBufferi            },
+    { "alGetBuffer3i",              wine_alGetBuffer3i           },
+    { "alGetBufferiv",              wine_alGetBufferiv           },
+    { "alDopplerFactor",            wine_alDopplerFactor         },
+    { "alDopplerVelocity",          wine_alDopplerVelocity       },
+    { "alSpeedOfSound",             wine_alSpeedOfSound          },
+    { "alDistanceModel",            wine_alDistanceModel         },
+    { NULL,                         NULL                         }
+};
diff --git a/dlls/openal32/openal32.spec b/dlls/openal32/openal32.spec
index 80a2a01cb41c9d5903f622d7c8d1ffdd0be74d34..0094fc23aa5d5fbf29ca81e429b49de509d5f0bf 100644
--- a/dlls/openal32/openal32.spec
+++ b/dlls/openal32/openal32.spec
@@ -1,97 +1,97 @@
 #OpenAL ALC_1_0
-@ stub alcCreateContext
-@ stub alcMakeContextCurrent
-@ stub alcProcessContext
-@ stub alcSuspendContext
-@ stub alcDestroyContext
-@ stub alcGetCurrentContext
-@ stub alcGetContextsDevice
-@ stub alcOpenDevice
-@ stub alcCloseDevice
-@ stub alcGetError
-@ stub alcIsExtensionPresent
-@ stub alcGetProcAddress
-@ stub alcGetEnumValue
-@ stub alcGetString
-@ stub alcGetIntegerv
+@ 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
-@ stub alEnable
-@ stub alDisable
-@ stub alIsEnabled
-@ stub alGetString
-@ stub alGetBooleanv
-@ stub alGetIntegerv
-@ stub alGetFloatv
-@ stub alGetDoublev
-@ stub alGetBoolean
-@ stub alGetInteger
-@ stub alGetFloat
-@ stub alGetDouble
-@ stub alGetError
-@ stub alIsExtensionPresent
-@ stub alGetProcAddress
-@ stub alGetEnumValue
-@ stub alListenerf
-@ stub alListener3f
-@ stub alListenerfv
-@ stub alListeneri
-@ stub alGetListenerf
-@ stub alGetListener3f
-@ stub alGetListenerfv
-@ stub alGetListeneri
-@ stub alGetListeneriv
-@ stub alGenSources
-@ stub alDeleteSources
-@ stub alIsSource
-@ stub alSourcef
-@ stub alSource3f
-@ stub alSourcefv
-@ stub alSourcei
-@ stub alGetSourcef
-@ stub alGetSource3f
-@ stub alGetSourcefv
-@ stub alGetSourcei
-@ stub alGetSourceiv
-@ stub alSourcePlayv
-@ stub alSourceStopv
-@ stub alSourceRewindv
-@ stub alSourcePausev
-@ stub alSourcePlay
-@ stub alSourceStop
-@ stub alSourceRewind
-@ stub alSourcePause
-@ stub alSourceQueueBuffers
-@ stub alSourceUnqueueBuffers
-@ stub alGenBuffers
-@ stub alDeleteBuffers
-@ stub alIsBuffer
-@ stub alBufferData
-@ stub alGetBufferf
-@ stub alGetBufferfv
-@ stub alGetBufferi
-@ stub alGetBufferiv
-@ stub alDopplerFactor
-@ stub alDopplerVelocity
-@ stub alDistanceModel
+@ 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
-@ stub alcCaptureOpenDevice
-@ stub alcCaptureCloseDevice
-@ stub alcCaptureStart
-@ stub alcCaptureStop
-@ stub alcCaptureSamples
+@ 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
-@ stub alListener3i
-@ stub alListeneriv
-@ stub alGetListener3i
-@ stub alSource3i
-@ stub alSourceiv
-@ stub alGetSource3i
-@ stub alBufferf
-@ stub alBuffer3f
-@ stub alBufferfv
-@ stub alBufferi
-@ stub alBuffer3i
-@ stub alBufferiv
-@ stub alGetBuffer3f
-@ stub alGetBuffer3i
-@ stub alSpeedOfSound
+@ 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