dlls/openal32/openal.c

   1 /*
   2  * OpenAL32.dll thunk. Wraps Win32 OpenAL function calls around a native
   3  * implementation.
   4  *
   5  * Copyright 2007 Nick Burns (adger44@hotmail.com)
   6  * Copyright 2007,2009 Chris Robinson
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <string.h>
  27
  28 #ifdef HAVE_AL_AL_H
  29 #include <AL/al.h>
  30 #include <AL/alc.h>
  31 #elif defined(HAVE_OPENAL_AL_H)
  32 #include <OpenAL/al.h>
  33 #include <OpenAL/alc.h>
  34 #endif
  35
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(openal32);
  41
  42 static ALCboolean  (ALC_APIENTRY*alcSetThreadContext)(ALCcontext *context);
  43 static ALCcontext* (ALC_APIENTRY*alcGetThreadContext)(ALCvoid);
  44
  45 static ALboolean loaded_procs;
  46
  47 static ALvoid (AL_APIENTRY*alBufferDataStatic)(const ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq);
  48 static ALvoid (AL_APIENTRY*alGenFilters)(ALsizei n, ALuint* filters);
  49 static ALvoid (AL_APIENTRY*alDeleteFilters)(ALsizei n, const ALuint* filters);
  50 static ALboolean (AL_APIENTRY*alIsFilter)(ALuint fid);
  51 static ALvoid (AL_APIENTRY*alFilterf)(ALuint fid, ALenum param, ALfloat value);
  52 static ALvoid (AL_APIENTRY*alFilterfv)(ALuint fid, ALenum param, const ALfloat* values);
  53 static ALvoid (AL_APIENTRY*alFilteri)(ALuint fid, ALenum param, ALint value);
  54 static ALvoid (AL_APIENTRY*alFilteriv)(ALuint fid, ALenum param, const ALint* values);
  55 static ALvoid (AL_APIENTRY*alGetFilterf)(ALuint fid, ALenum param, ALfloat* value);
  56 static ALvoid (AL_APIENTRY*alGetFilterfv)(ALuint fid, ALenum param, ALfloat* values);
  57 static ALvoid (AL_APIENTRY*alGetFilteri)(ALuint fid, ALenum param, ALint* value);
  58 static ALvoid (AL_APIENTRY*alGetFilteriv)(ALuint fid, ALenum param, ALint* values);
  59 static ALvoid (AL_APIENTRY*alGenEffects)(ALsizei n, ALuint* effects);
  60 static ALvoid (AL_APIENTRY*alDeleteEffects)(ALsizei n, const ALuint* effects);
  61 static ALboolean (AL_APIENTRY*alIsEffect)(ALuint eid);
  62 static ALvoid (AL_APIENTRY*alEffectf)(ALuint eid, ALenum param, ALfloat value);
  63 static ALvoid (AL_APIENTRY*alEffectfv)(ALuint eid, ALenum param, const ALfloat* values);
  64 static ALvoid (AL_APIENTRY*alEffecti)(ALuint eid, ALenum param, ALint value);
  65 static ALvoid (AL_APIENTRY*alEffectiv)(ALuint eid, ALenum param, const ALint* values);
  66 static ALvoid (AL_APIENTRY*alGetEffectf)(ALuint eid, ALenum param, ALfloat* value);
  67 static ALvoid (AL_APIENTRY*alGetEffectfv)(ALuint eid, ALenum param, ALfloat* values);
  68 static ALvoid (AL_APIENTRY*alGetEffecti)(ALuint eid, ALenum param, ALint* value);
  69 static ALvoid (AL_APIENTRY*alGetEffectiv)(ALuint eid, ALenum param, ALint* values);
  70 static ALvoid (AL_APIENTRY*alGenAuxiliaryEffectSlots)(ALsizei n, ALuint* slots);
  71 static ALvoid (AL_APIENTRY*alDeleteAuxiliaryEffectSlots)(ALsizei n, const ALuint* slots);
  72 static ALboolean (AL_APIENTRY*alIsAuxiliaryEffectSlot)(ALuint sid);
  73 static ALvoid (AL_APIENTRY*alAuxiliaryEffectSlotf)(ALuint sid, ALenum param, ALfloat value);
  74 static ALvoid (AL_APIENTRY*alAuxiliaryEffectSlotfv)(ALuint sid, ALenum param, const ALfloat* values);
  75 static ALvoid (AL_APIENTRY*alAuxiliaryEffectSloti)(ALuint sid, ALenum param, ALint value);
  76 static ALvoid (AL_APIENTRY*alAuxiliaryEffectSlotiv)(ALuint sid, ALenum param, const ALint* values);
  77 static ALvoid (AL_APIENTRY*alGetAuxiliaryEffectSlotf)(ALuint sid, ALenum param, ALfloat* value);
  78 static ALvoid (AL_APIENTRY*alGetAuxiliaryEffectSlotfv)(ALuint sid, ALenum param, ALfloat* values);
  79 static ALvoid (AL_APIENTRY*alGetAuxiliaryEffectSloti)(ALuint sid, ALenum param, ALint* value);
  80 static ALvoid (AL_APIENTRY*alGetAuxiliaryEffectSlotiv)(ALuint sid, ALenum param, ALint* values);
  81
  82 extern ALCvoid* CDECL wine_alcGetProcAddress(ALCdevice *, const ALCchar *);
  83 extern ALvoid*  CDECL wine_alGetProcAddress(const ALchar*);
  84
  85 static CRITICAL_SECTION openal_cs;
  86 static CRITICAL_SECTION_DEBUG openal_cs_debug =
  87 {
  88     0, 0, &openal_cs,
  89     {&openal_cs_debug.ProcessLocksList,
  90     &openal_cs_debug.ProcessLocksList},
  91     0, 0, {(DWORD_PTR)(__FILE__ ": openal_cs")}
  92 };
  93 static CRITICAL_SECTION openal_cs = {&openal_cs_debug, -1, 0, 0, 0, 0};
  94
  95 /***********************************************************************
  96  *           OpenAL initialisation routine
  97  */
  98 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
  99 {
 100     switch(reason)
 101     {
 102     case DLL_PROCESS_ATTACH:
 103         DisableThreadLibraryCalls(hinst);
 104 #define LOADFUNC(x) x = alcGetProcAddress(NULL, #x)
 105         LOADFUNC(alcSetThreadContext);
 106         LOADFUNC(alcGetThreadContext);
 107 #undef LOADFUNC
 108         break;
 109     case DLL_PROCESS_DETACH:
 110         if (reserved) break;
 111         DeleteCriticalSection(&openal_cs);
 112     }
 113
 114     return TRUE;
 115 }
 116
 117
 118 static void LoadProcs(void)
 119 {
 120 #define LOADFUNC(x) x = alGetProcAddress(#x)
 121     LOADFUNC(alBufferDataStatic);
 122     LOADFUNC(alGenFilters);
 123     LOADFUNC(alDeleteFilters);
 124     LOADFUNC(alIsFilter);
 125     LOADFUNC(alFilterf);
 126     LOADFUNC(alFilterfv);
 127     LOADFUNC(alFilteri);
 128     LOADFUNC(alFilteriv);
 129     LOADFUNC(alGetFilterf);
 130     LOADFUNC(alGetFilterfv);
 131     LOADFUNC(alGetFilteri);
 132     LOADFUNC(alGetFilteriv);
 133     LOADFUNC(alGenEffects);
 134     LOADFUNC(alDeleteEffects);
 135     LOADFUNC(alIsEffect);
 136     LOADFUNC(alEffectf);
 137     LOADFUNC(alEffectfv);
 138     LOADFUNC(alEffecti);
 139     LOADFUNC(alEffectiv);
 140     LOADFUNC(alGetEffectf);
 141     LOADFUNC(alGetEffectfv);
 142     LOADFUNC(alGetEffecti);
 143     LOADFUNC(alGetEffectiv);
 144     LOADFUNC(alGenAuxiliaryEffectSlots);
 145     LOADFUNC(alDeleteAuxiliaryEffectSlots);
 146     LOADFUNC(alIsAuxiliaryEffectSlot);
 147     LOADFUNC(alAuxiliaryEffectSlotf);
 148     LOADFUNC(alAuxiliaryEffectSlotfv);
 149     LOADFUNC(alAuxiliaryEffectSloti);
 150     LOADFUNC(alAuxiliaryEffectSlotiv);
 151     LOADFUNC(alGetAuxiliaryEffectSlotf);
 152     LOADFUNC(alGetAuxiliaryEffectSlotfv);
 153     LOADFUNC(alGetAuxiliaryEffectSloti);
 154     LOADFUNC(alGetAuxiliaryEffectSlotiv);
 155 #undef LOADFUNC
 156 }
 157
 158 /***********************************************************************
 159  *           OpenAL thunk routines
 160  */
 161
 162 /* OpenAL ALC 1.0 functions */
 163 ALCcontext* CDECL wine_alcCreateContext(ALCdevice *device, const ALCint* attrlist)
 164 {
 165     return alcCreateContext(device, attrlist);
 166 }
 167
 168 ALCboolean CDECL wine_alcMakeContextCurrent(ALCcontext *context)
 169 {
 170     EnterCriticalSection(&openal_cs);
 171     if(alcMakeContextCurrent(context) == ALC_FALSE)
 172     {
 173         WARN("Failed to make context %p current\n", context);
 174         LeaveCriticalSection(&openal_cs);
 175         return ALC_FALSE;
 176     }
 177
 178     if(context && !loaded_procs)
 179     {
 180         loaded_procs = AL_TRUE;
 181         LoadProcs();
 182     }
 183     LeaveCriticalSection(&openal_cs);
 184
 185     return ALC_TRUE;
 186 }
 187
 188 ALvoid CDECL wine_alcProcessContext(ALCcontext *context)
 189 {
 190     alcProcessContext(context);
 191 }
 192
 193 ALvoid CDECL wine_alcSuspendContext(ALCcontext *context)
 194 {
 195     alcSuspendContext(context);
 196 }
 197
 198 ALvoid CDECL wine_alcDestroyContext(ALCcontext *context)
 199 {
 200     alcDestroyContext(context);
 201 }
 202
 203 ALCcontext* CDECL wine_alcGetCurrentContext(ALCvoid)
 204 {
 205     return alcGetCurrentContext();
 206 }
 207
 208 ALCdevice* CDECL wine_alcGetContextsDevice(ALCcontext *context)
 209 {
 210     return alcGetContextsDevice(context);
 211 }
 212
 213 ALCdevice* CDECL wine_alcOpenDevice(const ALCchar *devicename)
 214 {
 215     if(devicename != NULL && (strcmp(devicename, "DirectSound3D") == 0 ||
 216                               strcmp(devicename, "DirectSound") == 0 ||
 217                               strcmp(devicename, "Generic Hardware") == 0 ||
 218                               strcmp(devicename, "Generic Software") == 0)) {
 219         devicename = NULL;
 220     }
 221     return alcOpenDevice(devicename);
 222 }
 223
 224 ALCboolean CDECL wine_alcCloseDevice(ALCdevice *device)
 225 {
 226     return alcCloseDevice(device);
 227 }
 228
 229 ALCenum CDECL wine_alcGetError(ALCdevice *device)
 230 {
 231     return alcGetError(device);
 232 }
 233
 234 ALCboolean CDECL wine_alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname)
 235 {
 236     return alcIsExtensionPresent(device, extname);
 237 }
 238
 239 ALCenum CDECL wine_alcGetEnumValue(ALCdevice *device, const ALCchar *enumname)
 240 {
 241     return alcGetEnumValue(device, enumname);
 242 }
 243
 244 const ALCchar* CDECL wine_alcGetString(ALCdevice *device, ALCenum param)
 245 {
 246     return alcGetString(device, param);
 247 }
 248
 249 ALvoid CDECL wine_alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest)
 250 {
 251     alcGetIntegerv(device, param, size, dest);
 252 }
 253
 254
 255 /* OpenAL 1.0 functions */
 256 ALvoid CDECL wine_alEnable(ALenum capability)
 257 {
 258     alEnable(capability);
 259 }
 260
 261 ALvoid CDECL wine_alDisable(ALenum capability)
 262 {
 263     alDisable(capability);
 264 }
 265
 266 ALboolean CDECL wine_alIsEnabled(ALenum capability)
 267 {
 268     return alIsEnabled(capability);
 269 }
 270
 271 const ALchar* CDECL wine_alGetString(ALenum param)
 272 {
 273     return alGetString(param);
 274 }
 275
 276 ALvoid CDECL wine_alGetBooleanv(ALenum param, ALboolean* data)
 277 {
 278     alGetBooleanv(param, data);
 279 }
 280
 281 ALvoid CDECL wine_alGetIntegerv(ALenum param, ALint* data)
 282 {
 283     alGetIntegerv(param, data);
 284 }
 285
 286 ALvoid CDECL wine_alGetFloatv(ALenum param, ALfloat* data)
 287 {
 288     alGetFloatv(param, data);
 289 }
 290
 291 ALvoid CDECL wine_alGetDoublev(ALenum param, ALdouble* data)
 292 {
 293     alGetDoublev(param, data);
 294 }
 295
 296 ALboolean CDECL wine_alGetBoolean(ALenum param)
 297 {
 298     return alGetBoolean(param);
 299 }
 300
 301 ALint CDECL wine_alGetInteger(ALenum param)
 302 {
 303     return alGetInteger(param);
 304 }
 305
 306 ALfloat CDECL wine_alGetFloat(ALenum param)
 307 {
 308     return alGetFloat(param);
 309 }
 310
 311 ALdouble CDECL wine_alGetDouble(ALenum param)
 312 {
 313     return alGetDouble(param);
 314 }
 315
 316 ALenum CDECL wine_alGetError(ALvoid)
 317 {
 318     return alGetError();
 319 }
 320
 321 ALboolean CDECL wine_alIsExtensionPresent(const ALchar* extname)
 322 {
 323     return alIsExtensionPresent(extname);
 324 }
 325
 326 ALenum CDECL wine_alGetEnumValue(const ALchar* ename)
 327 {
 328     return alGetEnumValue(ename);
 329 }
 330
 331 ALvoid CDECL wine_alListenerf(ALenum param, ALfloat value)
 332 {
 333     alListenerf(param, value);
 334 }
 335
 336 ALvoid CDECL wine_alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 337 {
 338     alListener3f(param, value1, value2, value3);
 339 }
 340
 341 ALvoid CDECL wine_alListenerfv(ALenum param, const ALfloat* values)
 342 {
 343     alListenerfv(param, values);
 344 }
 345
 346 ALvoid CDECL wine_alListeneri(ALenum param, ALint value)
 347 {
 348     alListeneri(param, value);
 349 }
 350
 351 ALvoid CDECL wine_alGetListenerf(ALenum param, ALfloat* value)
 352 {
 353     alGetListenerf(param, value);
 354 }
 355
 356 ALvoid CDECL wine_alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 357 {
 358     alGetListener3f(param, value1, value2, value3);
 359 }
 360
 361 ALvoid CDECL wine_alGetListenerfv(ALenum param, ALfloat* values)
 362 {
 363     alGetListenerfv(param, values);
 364 }
 365
 366 ALvoid CDECL wine_alGetListeneri(ALenum param, ALint* value)
 367 {
 368     alGetListeneri(param, value);
 369 }
 370
 371 ALvoid CDECL wine_alGetListeneriv(ALenum param, ALint* values)
 372 {
 373     alGetListeneriv(param, values);
 374 }
 375
 376 ALvoid CDECL wine_alGenSources(ALsizei n, ALuint* sources)
 377 {
 378     alGenSources(n, sources);
 379 }
 380
 381 ALvoid CDECL wine_alDeleteSources(ALsizei n, const ALuint* sources)
 382 {
 383     alDeleteSources(n, sources);
 384 }
 385
 386 ALboolean CDECL wine_alIsSource(ALuint sid)
 387 {
 388     return alIsSource(sid);
 389 }
 390
 391 ALvoid CDECL wine_alSourcef(ALuint sid, ALenum param, ALfloat value)
 392 {
 393     alSourcef(sid, param, value);
 394 }
 395
 396 ALvoid CDECL wine_alSource3f(ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 397 {
 398     alSource3f(sid, param, value1, value2, value3);
 399 }
 400
 401 ALvoid CDECL wine_alSourcefv(ALuint sid, ALenum param, const ALfloat* values)
 402 {
 403     alSourcefv(sid, param, values);
 404 }
 405
 406 ALvoid CDECL wine_alSourcei(ALuint sid, ALenum param, ALint value)
 407 {
 408     alSourcei(sid, param, value);
 409 }
 410
 411 ALvoid CDECL wine_alGetSourcef(ALuint sid, ALenum param, ALfloat* value)
 412 {
 413     alGetSourcef(sid, param, value);
 414 }
 415
 416 ALvoid CDECL wine_alGetSource3f(ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
 417 {
 418     alGetSource3f(sid, param, value1, value2, value3);
 419 }
 420
 421 ALvoid CDECL wine_alGetSourcefv(ALuint sid, ALenum param, ALfloat* values)
 422 {
 423     alGetSourcefv(sid, param, values);
 424 }
 425
 426 ALvoid CDECL wine_alGetSourcei(ALuint sid, ALenum param, ALint* value)
 427 {
 428     alGetSourcei(sid, param, value);
 429 }
 430
 431 ALvoid CDECL wine_alGetSourceiv(ALuint sid, ALenum param, ALint* values)
 432 {
 433     alGetSourceiv(sid, param, values);
 434 }
 435
 436 ALvoid CDECL wine_alSourcePlayv(ALsizei ns, const ALuint *sids)
 437 {
 438     alSourcePlayv(ns, sids);
 439 }
 440
 441 ALvoid CDECL wine_alSourceStopv(ALsizei ns, const ALuint *sids)
 442 {
 443     alSourceStopv(ns, sids);
 444 }
 445
 446 ALvoid CDECL wine_alSourceRewindv(ALsizei ns, const ALuint *sids)
 447 {
 448     alSourceRewindv(ns, sids);
 449 }
 450
 451 ALvoid CDECL wine_alSourcePausev(ALsizei ns, const ALuint *sids)
 452 {
 453     alSourcePausev(ns, sids);
 454 }
 455
 456 ALvoid CDECL wine_alSourcePlay(ALuint sid)
 457 {
 458     alSourcePlay(sid);
 459 }
 460
 461 ALvoid CDECL wine_alSourceStop(ALuint sid)
 462 {
 463     alSourceStop(sid);
 464 }
 465
 466 ALvoid CDECL wine_alSourceRewind(ALuint sid)
 467 {
 468     alSourceRewind(sid);
 469 }
 470
 471 ALvoid CDECL wine_alSourcePause(ALuint sid)
 472 {
 473     alSourcePause(sid);
 474 }
 475
 476 ALvoid CDECL wine_alSourceQueueBuffers(ALuint sid, ALsizei numEntries, const ALuint *bids)
 477 {
 478     alSourceQueueBuffers(sid, numEntries, bids);
 479 }
 480
 481 ALvoid CDECL wine_alSourceUnqueueBuffers(ALuint sid, ALsizei numEntries, ALuint *bids)
 482 {
 483     alSourceUnqueueBuffers(sid, numEntries, bids);
 484 }
 485
 486 ALvoid CDECL wine_alGenBuffers(ALsizei n, ALuint* buffers)
 487 {
 488     alGenBuffers(n, buffers);
 489 }
 490
 491 ALvoid CDECL wine_alDeleteBuffers(ALsizei n, const ALuint* buffers)
 492 {
 493     alDeleteBuffers(n, buffers);
 494 }
 495
 496 ALboolean CDECL wine_alIsBuffer(ALuint bid)
 497 {
 498     return alIsBuffer(bid);
 499 }
 500
 501 ALvoid CDECL wine_alBufferData(ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
 502 {
 503     alBufferData(bid, format, data, size, freq);
 504 }
 505
 506 static ALvoid CDECL wine_alBufferDataStatic(const ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
 507 {
 508     alBufferDataStatic(bid, format, data, size, freq);
 509 }
 510
 511 ALvoid CDECL wine_alGetBufferf(ALuint bid, ALenum param, ALfloat* value)
 512 {
 513     alGetBufferf(bid, param, value);
 514 }
 515
 516 ALvoid CDECL wine_alGetBufferfv(ALuint bid, ALenum param, ALfloat* values)
 517 {
 518     alGetBufferfv(bid, param, values);
 519 }
 520
 521 ALvoid CDECL wine_alGetBufferi(ALuint bid, ALenum param, ALint* value)
 522 {
 523     alGetBufferi(bid, param, value);
 524 }
 525
 526 ALvoid CDECL wine_alGetBufferiv(ALuint bid, ALenum param, ALint* values)
 527 {
 528     alGetBufferiv(bid, param, values);
 529 }
 530
 531 ALvoid CDECL wine_alDopplerFactor(ALfloat value)
 532 {
 533     alDopplerFactor(value);
 534 }
 535
 536 ALvoid CDECL wine_alDopplerVelocity(ALfloat value)
 537 {
 538     alDopplerVelocity(value);
 539 }
 540
 541 ALvoid CDECL wine_alDistanceModel(ALenum distanceModel)
 542 {
 543     alDistanceModel(distanceModel);
 544 }
 545
 546
 547 /* OpenAL ALC 1.1 functions */
 548 ALCdevice* CDECL wine_alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize)
 549 {
 550      return alcCaptureOpenDevice(devicename, frequency, format, buffersize);
 551 }
 552
 553 ALCboolean CDECL wine_alcCaptureCloseDevice(ALCdevice *device)
 554 {
 555     return alcCaptureCloseDevice(device);
 556 }
 557
 558 ALCvoid CDECL wine_alcCaptureStart(ALCdevice *device)
 559 {
 560     alcCaptureStart(device);
 561 }
 562
 563 ALCvoid CDECL wine_alcCaptureStop(ALCdevice *device)
 564 {
 565     alcCaptureStop(device);
 566 }
 567
 568 ALCvoid CDECL wine_alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
 569 {
 570     alcCaptureSamples(device, buffer, samples);
 571 }
 572
 573 /* OpenAL 1.1 functions */
 574 ALvoid CDECL wine_alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
 575 {
 576     alListener3i(param, value1, value2, value3);
 577 }
 578
 579 ALvoid CDECL wine_alListeneriv(ALenum param, const ALint* values)
 580 {
 581     alListeneriv(param, values);
 582 }
 583
 584 ALvoid CDECL wine_alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
 585 {
 586     alGetListener3i(param, value1, value2, value3);
 587 }
 588
 589 ALvoid CDECL wine_alSource3i(ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3)
 590 {
 591     alSource3i(sid, param, value1, value2, value3);
 592 }
 593
 594 ALvoid CDECL wine_alSourceiv(ALuint sid, ALenum param, const ALint* values)
 595 {
 596     alSourceiv(sid, param, values);
 597 }
 598
 599 ALvoid CDECL wine_alGetSource3i(ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
 600 {
 601     alGetSource3i(sid, param, value1, value2, value3);
 602 }
 603
 604 ALvoid CDECL wine_alBufferf(ALuint bid, ALenum param, ALfloat value)
 605 {
 606     alBufferf(bid, param, value);
 607 }
 608
 609 ALvoid CDECL wine_alBuffer3f(ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 610 {
 611     alBuffer3f(bid, param, value1, value2, value3);
 612 }
 613
 614 ALvoid CDECL wine_alBufferfv(ALuint bid, ALenum param, const ALfloat* values)
 615 {
 616     alBufferfv(bid, param, values);
 617 }
 618
 619 ALvoid CDECL wine_alBufferi(ALuint bid, ALenum param, ALint value)
 620 {
 621     alBufferi(bid, param, value);
 622 }
 623
 624 ALvoid CDECL wine_alBuffer3i(ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3)
 625 {
 626     alBuffer3i(bid, param, value1, value2, value3);
 627 }
 628
 629 ALvoid CDECL wine_alBufferiv(ALuint bid, ALenum param, const ALint* values)
 630 {
 631     alBufferiv(bid, param, values);
 632 }
 633
 634 ALvoid CDECL wine_alGetBuffer3f(ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
 635 {
 636     alGetBuffer3f(bid, param, value1, value2, value3);
 637 }
 638
 639 ALvoid CDECL wine_alGetBuffer3i(ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
 640 {
 641     alGetBuffer3i(bid, param, value1, value2, value3);
 642 }
 643
 644 ALvoid CDECL wine_alSpeedOfSound(ALfloat value)
 645 {
 646     alSpeedOfSound(value);
 647 }
 648
 649 /* OpenAL EFX extension functions */
 650 static ALvoid CDECL wine_alGenFilters(ALsizei n, ALuint* filters)
 651 {
 652     alGenFilters(n, filters);
 653 }
 654
 655 static ALvoid CDECL wine_alDeleteFilters(ALsizei n, const ALuint* filters)
 656 {
 657     alDeleteFilters(n, filters);
 658 }
 659
 660 static ALboolean CDECL wine_alIsFilter(ALuint fid)
 661 {
 662     return alIsFilter(fid);
 663 }
 664
 665 static ALvoid CDECL wine_alFilterf(ALuint fid, ALenum param, ALfloat value)
 666 {
 667     alFilterf(fid, param, value);
 668 }
 669
 670 static ALvoid CDECL wine_alFilterfv(ALuint fid, ALenum param, const ALfloat* values)
 671 {
 672     alFilterfv(fid, param, values);
 673 }
 674
 675 static ALvoid CDECL wine_alFilteri(ALuint fid, ALenum param, ALint value)
 676 {
 677     alFilteri(fid, param, value);
 678 }
 679
 680 static ALvoid CDECL wine_alFilteriv(ALuint fid, ALenum param, const ALint* values)
 681 {
 682     alFilteriv(fid, param, values);
 683 }
 684
 685 static ALvoid CDECL wine_alGetFilterf(ALuint fid, ALenum param, ALfloat* value)
 686 {
 687     alGetFilterf(fid, param, value);
 688 }
 689
 690 static ALvoid CDECL wine_alGetFilterfv(ALuint fid, ALenum param, ALfloat* values)
 691 {
 692     alGetFilterfv(fid, param, values);
 693 }
 694
 695 static ALvoid CDECL wine_alGetFilteri(ALuint fid, ALenum param, ALint* value)
 696 {
 697     alGetFilteri(fid, param, value);
 698 }
 699
 700 static ALvoid CDECL wine_alGetFilteriv(ALuint fid, ALenum param, ALint* values)
 701 {
 702     alGetFilteriv(fid, param, values);
 703 }
 704
 705
 706 static ALvoid CDECL wine_alGenEffects(ALsizei n, ALuint* effects)
 707 {
 708     alGenEffects(n, effects);
 709 }
 710
 711 static ALvoid CDECL wine_alDeleteEffects(ALsizei n, const ALuint* effects)
 712 {
 713     alDeleteEffects(n, effects);
 714 }
 715
 716 static ALboolean CDECL wine_alIsEffect(ALuint eid)
 717 {
 718     return alIsEffect(eid);
 719 }
 720
 721 static ALvoid CDECL wine_alEffectf(ALuint eid, ALenum param, ALfloat value)
 722 {
 723     alEffectf(eid, param, value);
 724 }
 725
 726 static ALvoid CDECL wine_alEffectfv(ALuint eid, ALenum param, const ALfloat* values)
 727 {
 728     alEffectfv(eid, param, values);
 729 }
 730
 731 static ALvoid CDECL wine_alEffecti(ALuint eid, ALenum param, ALint value)
 732 {
 733     alEffecti(eid, param, value);
 734 }
 735
 736 static ALvoid CDECL wine_alEffectiv(ALuint eid, ALenum param, const ALint* values)
 737 {
 738     alEffectiv(eid, param, values);
 739 }
 740
 741 static ALvoid CDECL wine_alGetEffectf(ALuint eid, ALenum param, ALfloat* value)
 742 {
 743     alGetEffectf(eid, param, value);
 744 }
 745
 746 static ALvoid CDECL wine_alGetEffectfv(ALuint eid, ALenum param, ALfloat* values)
 747 {
 748     alGetEffectfv(eid, param, values);
 749 }
 750
 751 static ALvoid CDECL wine_alGetEffecti(ALuint eid, ALenum param, ALint* value)
 752 {
 753     alGetEffecti(eid, param, value);
 754 }
 755
 756 static ALvoid CDECL wine_alGetEffectiv(ALuint eid, ALenum param, ALint* values)
 757 {
 758     alGetEffectiv(eid, param, values);
 759 }
 760
 761
 762 static ALvoid CDECL wine_alGenAuxiliaryEffectSlots(ALsizei n, ALuint* slots)
 763 {
 764     alGenAuxiliaryEffectSlots(n, slots);
 765 }
 766
 767 static ALvoid CDECL wine_alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint* slots)
 768 {
 769     alDeleteAuxiliaryEffectSlots(n, slots);
 770 }
 771
 772 static ALboolean CDECL wine_alIsAuxiliaryEffectSlot(ALuint sid)
 773 {
 774     return alIsAuxiliaryEffectSlot(sid);
 775 }
 776
 777 static ALvoid CDECL wine_alAuxiliaryEffectSlotf(ALuint sid, ALenum param, ALfloat value)
 778 {
 779     alAuxiliaryEffectSlotf(sid, param, value);
 780 }
 781
 782 static ALvoid CDECL wine_alAuxiliaryEffectSlotfv(ALuint sid, ALenum param, const ALfloat* values)
 783 {
 784     alAuxiliaryEffectSlotfv(sid, param, values);
 785 }
 786
 787 static ALvoid CDECL wine_alAuxiliaryEffectSloti(ALuint sid, ALenum param, ALint value)
 788 {
 789     alAuxiliaryEffectSloti(sid, param, value);
 790 }
 791
 792 static ALvoid CDECL wine_alAuxiliaryEffectSlotiv(ALuint sid, ALenum param, const ALint* values)
 793 {
 794     alAuxiliaryEffectSlotiv(sid, param, values);
 795 }
 796
 797 static ALvoid CDECL wine_alGetAuxiliaryEffectSlotf(ALuint sid, ALenum param, ALfloat* value)
 798 {
 799     alGetAuxiliaryEffectSlotf(sid, param, value);
 800 }
 801
 802 static ALvoid CDECL wine_alGetAuxiliaryEffectSlotfv(ALuint sid, ALenum param, ALfloat* values)
 803 {
 804     alGetAuxiliaryEffectSlotfv(sid, param, values);
 805 }
 806
 807 static ALvoid CDECL wine_alGetAuxiliaryEffectSloti(ALuint sid, ALenum param, ALint* value)
 808 {
 809     alGetAuxiliaryEffectSloti(sid, param, value);
 810 }
 811
 812 static ALvoid CDECL wine_alGetAuxiliaryEffectSlotiv(ALuint sid, ALenum param, ALint* values)
 813 {
 814     alGetAuxiliaryEffectSlotiv(sid, param, values);
 815 }
 816
 817
 818 /* Thread-local context functions */
 819 static ALCboolean CDECL wine_alcSetThreadContext(ALCcontext *context)
 820 {
 821     EnterCriticalSection(&openal_cs);
 822     if(alcSetThreadContext(context) == ALC_FALSE)
 823     {
 824         WARN("Failed to make context %p current\n", context);
 825         LeaveCriticalSection(&openal_cs);
 826         return ALC_FALSE;
 827     }
 828
 829     if(context && !loaded_procs)
 830     {
 831         loaded_procs = AL_TRUE;
 832         LoadProcs();
 833     }
 834     LeaveCriticalSection(&openal_cs);
 835
 836     return ALC_TRUE;
 837 }
 838
 839 static ALCcontext* CDECL wine_alcGetThreadContext(ALCvoid)
 840 {
 841     return alcGetThreadContext();
 842 }
 843
 844 struct FuncList {
 845     const char *name;
 846     void *proc;
 847 };
 848
 849 static const struct FuncList ALCFuncs[] = {
 850     { "alcCreateContext",           wine_alcCreateContext        },
 851     { "alcMakeContextCurrent",      wine_alcMakeContextCurrent   },
 852     { "alcProcessContext",          wine_alcProcessContext       },
 853     { "alcSuspendContext",          wine_alcSuspendContext       },
 854     { "alcDestroyContext",          wine_alcDestroyContext       },
 855     { "alcGetCurrentContext",       wine_alcGetCurrentContext    },
 856     { "alcGetContextsDevice",       wine_alcGetContextsDevice    },
 857     { "alcOpenDevice",              wine_alcOpenDevice           },
 858     { "alcCloseDevice",             wine_alcCloseDevice          },
 859     { "alcGetError",                wine_alcGetError             },
 860     { "alcIsExtensionPresent",      wine_alcIsExtensionPresent   },
 861     { "alcGetProcAddress",          wine_alcGetProcAddress       },
 862     { "alcGetEnumValue",            wine_alcGetEnumValue         },
 863     { "alcGetString",               wine_alcGetString            },
 864     { "alcGetIntegerv",             wine_alcGetIntegerv          },
 865     { "alcCaptureOpenDevice",       wine_alcCaptureOpenDevice    },
 866     { "alcCaptureCloseDevice",      wine_alcCaptureCloseDevice   },
 867     { "alcCaptureStart",            wine_alcCaptureStart         },
 868     { "alcCaptureStop",             wine_alcCaptureStop          },
 869     { "alcCaptureSamples",          wine_alcCaptureSamples       },
 870     { "alcSetThreadContext",        wine_alcSetThreadContext     },
 871     { "alcGetThreadContext",        wine_alcGetThreadContext     },
 872     { NULL,                         NULL                         }
 873 };
 874 static const struct FuncList ALFuncs[] = {
 875     { "alEnable",                   wine_alEnable                },
 876     { "alDisable",                  wine_alDisable               },
 877     { "alIsEnabled",                wine_alIsEnabled             },
 878     { "alGetString",                wine_alGetString             },
 879     { "alGetBooleanv",              wine_alGetBooleanv           },
 880     { "alGetIntegerv",              wine_alGetIntegerv           },
 881     { "alGetFloatv",                wine_alGetFloatv             },
 882     { "alGetDoublev",               wine_alGetDoublev            },
 883     { "alGetBoolean",               wine_alGetBoolean            },
 884     { "alGetInteger",               wine_alGetInteger            },
 885     { "alGetFloat",                 wine_alGetFloat              },
 886     { "alGetDouble",                wine_alGetDouble             },
 887     { "alGetError",                 wine_alGetError              },
 888     { "alIsExtensionPresent",       wine_alIsExtensionPresent    },
 889     { "alGetProcAddress",           wine_alGetProcAddress        },
 890     { "alGetEnumValue",             wine_alGetEnumValue          },
 891     { "alListenerf",                wine_alListenerf             },
 892     { "alListener3f",               wine_alListener3f            },
 893     { "alListenerfv",               wine_alListenerfv            },
 894     { "alListeneri",                wine_alListeneri             },
 895     { "alListener3i",               wine_alListener3i            },
 896     { "alListeneriv",               wine_alListeneriv            },
 897     { "alGetListenerf",             wine_alGetListenerf          },
 898     { "alGetListener3f",            wine_alGetListener3f         },
 899     { "alGetListenerfv",            wine_alGetListenerfv         },
 900     { "alGetListeneri",             wine_alGetListeneri          },
 901     { "alGetListener3i",            wine_alGetListener3i         },
 902     { "alGetListeneriv",            wine_alGetListeneriv         },
 903     { "alGenSources",               wine_alGenSources            },
 904     { "alDeleteSources",            wine_alDeleteSources         },
 905     { "alIsSource",                 wine_alIsSource              },
 906     { "alSourcef",                  wine_alSourcef               },
 907     { "alSource3f",                 wine_alSource3f              },
 908     { "alSourcefv",                 wine_alSourcefv              },
 909     { "alSourcei",                  wine_alSourcei               },
 910     { "alSource3i",                 wine_alSource3i              },
 911     { "alSourceiv",                 wine_alSourceiv              },
 912     { "alGetSourcef",               wine_alGetSourcef            },
 913     { "alGetSource3f",              wine_alGetSource3f           },
 914     { "alGetSourcefv",              wine_alGetSourcefv           },
 915     { "alGetSourcei",               wine_alGetSourcei            },
 916     { "alGetSource3i",              wine_alGetSource3i           },
 917     { "alGetSourceiv",              wine_alGetSourceiv           },
 918     { "alSourcePlayv",              wine_alSourcePlayv           },
 919     { "alSourceStopv",              wine_alSourceStopv           },
 920     { "alSourceRewindv",            wine_alSourceRewindv         },
 921     { "alSourcePausev",             wine_alSourcePausev          },
 922     { "alSourcePlay",               wine_alSourcePlay            },
 923     { "alSourceStop",               wine_alSourceStop            },
 924     { "alSourceRewind",             wine_alSourceRewind          },
 925     { "alSourcePause",              wine_alSourcePause           },
 926     { "alSourceQueueBuffers",       wine_alSourceQueueBuffers    },
 927     { "alSourceUnqueueBuffers",     wine_alSourceUnqueueBuffers  },
 928     { "alGenBuffers",               wine_alGenBuffers            },
 929     { "alDeleteBuffers",            wine_alDeleteBuffers         },
 930     { "alIsBuffer",                 wine_alIsBuffer              },
 931     { "alBufferData",               wine_alBufferData            },
 932     { "alBufferDataStatic",         wine_alBufferDataStatic      },
 933     { "alBufferf",                  wine_alBufferf               },
 934     { "alBuffer3f",                 wine_alBuffer3f              },
 935     { "alBufferfv",                 wine_alBufferfv              },
 936     { "alBufferi",                  wine_alBufferi               },
 937     { "alBuffer3i",                 wine_alBuffer3i              },
 938     { "alBufferiv",                 wine_alBufferiv              },
 939     { "alGetBufferf",               wine_alGetBufferf            },
 940     { "alGetBuffer3f",              wine_alGetBuffer3f           },
 941     { "alGetBufferfv",              wine_alGetBufferfv           },
 942     { "alGetBufferi",               wine_alGetBufferi            },
 943     { "alGetBuffer3i",              wine_alGetBuffer3i           },
 944     { "alGetBufferiv",              wine_alGetBufferiv           },
 945     { "alDopplerFactor",            wine_alDopplerFactor         },
 946     { "alDopplerVelocity",          wine_alDopplerVelocity       },
 947     { "alSpeedOfSound",             wine_alSpeedOfSound          },
 948     { "alDistanceModel",            wine_alDistanceModel         },
 949
 950     { "alGenFilters",               wine_alGenFilters            },
 951     { "alDeleteFilters",            wine_alDeleteFilters         },
 952     { "alIsFilter",                 wine_alIsFilter              },
 953     { "alFilterf",                  wine_alFilterf               },
 954     { "alFilterfv",                 wine_alFilterfv              },
 955     { "alFilteri",                  wine_alFilteri               },
 956     { "alFilteriv",                 wine_alFilteriv              },
 957     { "alGetFilterf",               wine_alGetFilterf            },
 958     { "alGetFilterfv",              wine_alGetFilterfv           },
 959     { "alGetFilteri",               wine_alGetFilteri            },
 960     { "alGetFilteriv",              wine_alGetFilteriv           },
 961
 962     { "alGenEffects",               wine_alGenEffects            },
 963     { "alDeleteEffects",            wine_alDeleteEffects         },
 964     { "alIsEffect",                 wine_alIsEffect              },
 965     { "alEffectf",                  wine_alEffectf               },
 966     { "alEffectfv",                 wine_alEffectfv              },
 967     { "alEffecti",                  wine_alEffecti               },
 968     { "alEffectiv",                 wine_alEffectiv              },
 969     { "alGetEffectf",               wine_alGetEffectf            },
 970     { "alGetEffectfv",              wine_alGetEffectfv           },
 971     { "alGetEffecti",               wine_alGetEffecti            },
 972     { "alGetEffectiv",              wine_alGetEffectiv           },
 973
 974     { "alGenAuxiliaryEffectSlots",  wine_alGenAuxiliaryEffectSlots},
 975     { "alDeleteAuxiliaryEffectSlots",wine_alDeleteAuxiliaryEffectSlots},
 976     { "alIsAuxiliaryEffectSlot",    wine_alIsAuxiliaryEffectSlot },
 977     { "alAuxiliaryEffectSlotf",     wine_alAuxiliaryEffectSlotf  },
 978     { "alAuxiliaryEffectSlotfv",    wine_alAuxiliaryEffectSlotfv },
 979     { "alAuxiliaryEffectSloti",     wine_alAuxiliaryEffectSloti  },
 980     { "alAuxiliaryEffectSlotiv",    wine_alAuxiliaryEffectSlotiv },
 981     { "alGetAuxiliaryEffectSlotf",  wine_alGetAuxiliaryEffectSlotf},
 982     { "alGetAuxiliaryEffectSlotfv", wine_alGetAuxiliaryEffectSlotfv},
 983     { "alGetAuxiliaryEffectSloti",  wine_alGetAuxiliaryEffectSloti},
 984     { "alGetAuxiliaryEffectSlotiv", wine_alGetAuxiliaryEffectSlotiv},
 985
 986     { NULL,                         NULL                         }
 987 };
 988
 989
 990 ALCvoid* CDECL wine_alcGetProcAddress(ALCdevice *device, const ALCchar *funcname)
 991 {
 992     void *proc;
 993     int i;
 994
 995     /* Make sure the host implementation has the requested function */
 996     proc = alcGetProcAddress(device, funcname);
 997     if(!proc)
 998         return NULL;
 999
1000     for(i = 0;ALCFuncs[i].name;i++)
1001     {
1002         if(strcmp(funcname, ALCFuncs[i].name) == 0)
1003             return ALCFuncs[i].proc;
1004     }
1005     FIXME("Could not find function in list: %s\n", funcname);
1006     return NULL;
1007 }
1008
1009
1010 ALvoid* CDECL wine_alGetProcAddress(const ALchar* funcname)
1011 {
1012     void *proc;
1013     int i;
1014
1015     /* Make sure the host implementation has the requested function. This will
1016      * also set the last AL error properly if the function should not be
1017      * returned (eg. no current context). */
1018     proc = alGetProcAddress(funcname);
1019     if(!proc)
1020         return NULL;
1021
1022     for(i = 0;ALFuncs[i].name;i++)
1023     {
1024         if(strcmp(funcname, ALFuncs[i].name) == 0)
1025             return ALFuncs[i].proc;
1026     }
1027     FIXME("Could not find function in list: %s\n", funcname);
1028     return NULL;
1029 }