From d973953bbf8000bb81df1c2196b54046812c63d1 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Tue, 25 Aug 2009 04:30:25 -0700 Subject: [PATCH] openal32: Fill out thunk functions. --- dlls/openal32/openal.c | 625 +++++++++++++++++++++++++++++++++++++++++++- dlls/openal32/openal32.spec | 194 +++++++------- 2 files changed, 720 insertions(+), 99 deletions(-) rewrite dlls/openal32/openal32.spec (96%) diff --git a/dlls/openal32/openal.c b/dlls/openal32/openal.c index b2ee1e99d82..840498d2dc7 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 +#include +#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 dissimilarity index 96% index 80a2a01cb41..0094fc23aa5 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 -#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 -#OpenAL ALC_1_1 -@ stub alcCaptureOpenDevice -@ stub alcCaptureCloseDevice -@ stub alcCaptureStart -@ stub alcCaptureStop -@ stub 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 +#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 -- 2.11.4.GIT