openal32: Fill out thunk functions.

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:
+    case DLL_PROCESS_ATTACH:
-        return FALSE; /* prefer native version */
+        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                         }
+};

dlls/openal32/openal32.spec

@@ -1,97 +1,97 @@
 #OpenAL ALC_1_0
-@ stub alcCreateContext
+@ cdecl alcCreateContext(ptr ptr) wine_alcCreateContext
-@ stub alcMakeContextCurrent
+@ cdecl alcMakeContextCurrent(ptr) wine_alcMakeContextCurrent
-@ stub alcProcessContext
+@ cdecl alcProcessContext(ptr) wine_alcProcessContext
-@ stub alcSuspendContext
+@ cdecl alcSuspendContext(ptr) wine_alcSuspendContext
-@ stub alcDestroyContext
+@ cdecl alcDestroyContext(ptr) wine_alcDestroyContext
-@ stub alcGetCurrentContext
+@ cdecl alcGetCurrentContext() wine_alcGetCurrentContext
-@ stub alcGetContextsDevice
+@ cdecl alcGetContextsDevice(ptr) wine_alcGetContextsDevice
-@ stub alcOpenDevice
+@ cdecl alcOpenDevice(str) wine_alcOpenDevice
-@ stub alcCloseDevice
+@ cdecl alcCloseDevice(ptr) wine_alcCloseDevice
-@ stub alcGetError
+@ cdecl alcGetError(ptr) wine_alcGetError
-@ stub alcIsExtensionPresent
+@ cdecl alcIsExtensionPresent(ptr str) wine_alcIsExtensionPresent
-@ stub alcGetProcAddress
+@ cdecl alcGetProcAddress(ptr str) wine_alcGetProcAddress
-@ stub alcGetEnumValue
+@ cdecl alcGetEnumValue(ptr str) wine_alcGetEnumValue
-@ stub alcGetString
+@ cdecl alcGetString(ptr long) wine_alcGetString
-@ stub alcGetIntegerv
+@ cdecl alcGetIntegerv(ptr long long ptr) wine_alcGetIntegerv
 #OpenAL AL_1_0
-@ stub alEnable
+@ cdecl alEnable(long) wine_alEnable
-@ stub alDisable
+@ cdecl alDisable(long) wine_alDisable
-@ stub alIsEnabled
+@ cdecl alIsEnabled(long) wine_alIsEnabled
-@ stub alGetString
+@ cdecl alGetString(long) wine_alGetString
-@ stub alGetBooleanv
+@ cdecl alGetBooleanv(long ptr) wine_alGetBooleanv
-@ stub alGetIntegerv
+@ cdecl alGetIntegerv(long ptr) wine_alGetIntegerv
-@ stub alGetFloatv
+@ cdecl alGetFloatv(long ptr) wine_alGetFloatv
-@ stub alGetDoublev
+@ cdecl alGetDoublev(long ptr) wine_alGetDoublev
-@ stub alGetBoolean
+@ cdecl alGetBoolean(long) wine_alGetBoolean
-@ stub alGetInteger
+@ cdecl alGetInteger(long) wine_alGetInteger
-@ stub alGetFloat
+@ cdecl alGetFloat(long) wine_alGetFloat
-@ stub alGetDouble
+@ cdecl alGetDouble(long) wine_alGetDouble
-@ stub alGetError
+@ cdecl alGetError() wine_alGetError
-@ stub alIsExtensionPresent
+@ cdecl alIsExtensionPresent(str) wine_alIsExtensionPresent
-@ stub alGetProcAddress
+@ cdecl alGetProcAddress(str) wine_alGetProcAddress
-@ stub alGetEnumValue
+@ cdecl alGetEnumValue(str) wine_alGetEnumValue
-@ stub alListenerf
+@ cdecl alListenerf(long long) wine_alListenerf
-@ stub alListener3f
+@ cdecl alListener3f(long long long long) wine_alListener3f
-@ stub alListenerfv
+@ cdecl alListenerfv(long ptr) wine_alListenerfv
-@ stub alListeneri
+@ cdecl alListeneri(long long) wine_alListeneri
-@ stub alGetListenerf
+@ cdecl alGetListenerf(long ptr) wine_alGetListenerf
-@ stub alGetListener3f
+@ cdecl alGetListener3f(long ptr ptr ptr) wine_alGetListener3f
-@ stub alGetListenerfv
+@ cdecl alGetListenerfv(long ptr) wine_alGetListenerfv
-@ stub alGetListeneri
+@ cdecl alGetListeneri(long ptr) wine_alGetListeneri
-@ stub alGetListeneriv
+@ cdecl alGetListeneriv(long ptr) wine_alGetListeneriv
-@ stub alGenSources
+@ cdecl alGenSources(long ptr) wine_alGenSources
-@ stub alDeleteSources
+@ cdecl alDeleteSources(long ptr) wine_alDeleteSources
-@ stub alIsSource
+@ cdecl alIsSource(long) wine_alIsSource
-@ stub alSourcef
+@ cdecl alSourcef(long long long) wine_alSourcef
-@ stub alSource3f
+@ cdecl alSource3f(long long long long long) wine_alSource3f
-@ stub alSourcefv
+@ cdecl alSourcefv(long long ptr) wine_alSourcefv
-@ stub alSourcei
+@ cdecl alSourcei(long long long) wine_alSourcei
-@ stub alGetSourcef
+@ cdecl alGetSourcef(long long ptr) wine_alGetSourcef
-@ stub alGetSource3f
+@ cdecl alGetSource3f(long long ptr ptr ptr) wine_alGetSource3f
-@ stub alGetSourcefv
+@ cdecl alGetSourcefv(long long ptr) wine_alGetSourcefv
-@ stub alGetSourcei
+@ cdecl alGetSourcei(long long ptr) wine_alGetSourcei
-@ stub alGetSourceiv
+@ cdecl alGetSourceiv(long long ptr) wine_alGetSourceiv
-@ stub alSourcePlayv
+@ cdecl alSourcePlayv(long ptr) wine_alSourcePlayv
-@ stub alSourceStopv
+@ cdecl alSourceStopv(long ptr) wine_alSourceStopv
-@ stub alSourceRewindv
+@ cdecl alSourceRewindv(long ptr) wine_alSourceRewindv
-@ stub alSourcePausev
+@ cdecl alSourcePausev(long ptr) wine_alSourcePausev
-@ stub alSourcePlay
+@ cdecl alSourcePlay(long) wine_alSourcePlay
-@ stub alSourceStop
+@ cdecl alSourceStop(long) wine_alSourceStop
-@ stub alSourceRewind
+@ cdecl alSourceRewind(long) wine_alSourceRewind
-@ stub alSourcePause
+@ cdecl alSourcePause(long) wine_alSourcePause
-@ stub alSourceQueueBuffers
+@ cdecl alSourceQueueBuffers(long long ptr) wine_alSourceQueueBuffers
-@ stub alSourceUnqueueBuffers
+@ cdecl alSourceUnqueueBuffers(long long ptr) wine_alSourceUnqueueBuffers
-@ stub alGenBuffers
+@ cdecl alGenBuffers(long ptr) wine_alGenBuffers
-@ stub alDeleteBuffers
+@ cdecl alDeleteBuffers(long ptr) wine_alDeleteBuffers
-@ stub alIsBuffer
+@ cdecl alIsBuffer(long) wine_alIsBuffer
-@ stub alBufferData
+@ cdecl alBufferData(long long ptr long long) wine_alBufferData
-@ stub alGetBufferf
+@ cdecl alGetBufferf(long long ptr) wine_alGetBufferf
-@ stub alGetBufferfv
+@ cdecl alGetBufferfv(long long ptr) wine_alGetBufferfv
-@ stub alGetBufferi
+@ cdecl alGetBufferi(long long ptr) wine_alGetBufferi
-@ stub alGetBufferiv
+@ cdecl alGetBufferiv(long long ptr) wine_alGetBufferiv
-@ stub alDopplerFactor
+@ cdecl alDopplerFactor(long) wine_alDopplerFactor
-@ stub alDopplerVelocity
+@ cdecl alDopplerVelocity(long) wine_alDopplerVelocity
-@ stub alDistanceModel
+@ cdecl alDistanceModel(long) wine_alDistanceModel
 #OpenAL ALC_1_1
-@ stub alcCaptureOpenDevice
+@ cdecl alcCaptureOpenDevice(str long long long) wine_alcCaptureOpenDevice
-@ stub alcCaptureCloseDevice
+@ cdecl alcCaptureCloseDevice(ptr) wine_alcCaptureCloseDevice
-@ stub alcCaptureStart
+@ cdecl alcCaptureStart(ptr) wine_alcCaptureStart
-@ stub alcCaptureStop
+@ cdecl alcCaptureStop(ptr) wine_alcCaptureStop
-@ stub alcCaptureSamples
+@ cdecl alcCaptureSamples(ptr ptr long) wine_alcCaptureSamples
 #OpenAL AL_1_1
-@ stub alListener3i
+@ cdecl alListener3i(long long long long) wine_alListener3i
-@ stub alListeneriv
+@ cdecl alListeneriv(long ptr) wine_alListeneriv
-@ stub alGetListener3i
+@ cdecl alGetListener3i(long ptr ptr ptr) wine_alGetListener3i
-@ stub alSource3i
+@ cdecl alSource3i(long long long long long) wine_alSource3i
-@ stub alSourceiv
+@ cdecl alSourceiv(long long ptr) wine_alSourceiv
-@ stub alGetSource3i
+@ cdecl alGetSource3i(long long ptr ptr ptr) wine_alGetSource3i
-@ stub alBufferf
+@ cdecl alBufferf(long long long) wine_alBufferf
-@ stub alBuffer3f
+@ cdecl alBuffer3f(long long long long long) wine_alBuffer3f
-@ stub alBufferfv
+@ cdecl alBufferfv(long long ptr) wine_alBufferfv
-@ stub alBufferi
+@ cdecl alBufferi(long long long) wine_alBufferi
-@ stub alBuffer3i
+@ cdecl alBuffer3i(long long long long long) wine_alBuffer3i
-@ stub alBufferiv
+@ cdecl alBufferiv(long long ptr) wine_alBufferiv
-@ stub alGetBuffer3f
+@ cdecl alGetBuffer3f(long long ptr ptr ptr) wine_alGetBuffer3f
-@ stub alGetBuffer3i
+@ cdecl alGetBuffer3i(long long ptr ptr ptr) wine_alGetBuffer3i
-@ stub alSpeedOfSound
+@ cdecl alSpeedOfSound(long) wine_alSpeedOfSound