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 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wine/debug.h"
  31
  32 #ifdef HAVE_AL_AL_H
  33 #include <AL/al.h>
  34 #include <AL/alc.h>
  35 #endif
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(openal32);
  38
  39
  40 struct FuncList {
  41     const char *name;
  42     void *proc;
  43 };
  44
  45 static const struct FuncList ALCFuncs[];
  46 static const struct FuncList ALFuncs[];
  47
  48
  49 /***********************************************************************
  50  *           OpenAL initialisation routine
  51  */
  52 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
  53 {
  54     switch(reason)
  55     {
  56     case DLL_PROCESS_ATTACH:
  57         DisableThreadLibraryCalls(hinst);
  58         break;
  59     }
  60
  61     return TRUE;
  62 }
  63
  64
  65 /***********************************************************************
  66  *           OpenAL thunk routines
  67  */
  68
  69 /* OpenAL ALC 1.0 functions */
  70 ALCcontext* CDECL wine_alcCreateContext(ALCdevice *device, const ALCint* attrlist)
  71 {
  72     return alcCreateContext(device, attrlist);
  73 }
  74
  75 ALCboolean CDECL wine_alcMakeContextCurrent(ALCcontext *context)
  76 {
  77     return alcMakeContextCurrent(context);
  78 }
  79
  80 ALvoid CDECL wine_alcProcessContext(ALCcontext *context)
  81 {
  82     alcProcessContext(context);
  83 }
  84
  85 ALvoid CDECL wine_alcSuspendContext(ALCcontext *context)
  86 {
  87     alcSuspendContext(context);
  88 }
  89
  90 ALvoid CDECL wine_alcDestroyContext(ALCcontext *context)
  91 {
  92     alcDestroyContext(context);
  93 }
  94
  95 ALCcontext* CDECL wine_alcGetCurrentContext(ALCvoid)
  96 {
  97     return alcGetCurrentContext();
  98 }
  99
 100 ALCdevice* CDECL wine_alcGetContextsDevice(ALCcontext *context)
 101 {
 102     return alcGetContextsDevice(context);
 103 }
 104
 105 ALCdevice* CDECL wine_alcOpenDevice(const ALCchar *devicename)
 106 {
 107     return alcOpenDevice(devicename);
 108 }
 109
 110 ALCboolean CDECL wine_alcCloseDevice(ALCdevice *device)
 111 {
 112     return alcCloseDevice(device);
 113 }
 114
 115 ALCenum CDECL wine_alcGetError(ALCdevice *device)
 116 {
 117     return alcGetError(device);
 118 }
 119
 120 ALCboolean CDECL wine_alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname)
 121 {
 122     return alcIsExtensionPresent(device, extname);
 123 }
 124
 125 ALCvoid* CDECL wine_alcGetProcAddress(ALCdevice *device, const ALCchar *funcname)
 126 {
 127     void *proc;
 128     int i;
 129
 130     /* Make sure the host implementation has the requested function */
 131     proc = alcGetProcAddress(device, funcname);
 132     if(!proc)
 133         return NULL;
 134
 135     for(i = 0;ALCFuncs[i].name;i++)
 136     {
 137         if(strcmp(funcname, ALCFuncs[i].name) == 0)
 138             return ALCFuncs[i].proc;
 139     }
 140     FIXME("Could not find function in list: %s\n", funcname);
 141     return NULL;
 142 }
 143
 144 ALCenum CDECL wine_alcGetEnumValue(ALCdevice *device, const ALCchar *enumname)
 145 {
 146     return alcGetEnumValue(device, enumname);
 147 }
 148
 149 const ALCchar* CDECL wine_alcGetString(ALCdevice *device, ALCenum param)
 150 {
 151     return alcGetString(device, param);
 152 }
 153
 154 ALvoid CDECL wine_alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest)
 155 {
 156     return alcGetIntegerv(device, param, size, dest);
 157 }
 158
 159
 160 /* OpenAL 1.0 functions */
 161 ALvoid CDECL wine_alEnable(ALenum capability)
 162 {
 163     alEnable(capability);
 164 }
 165
 166 ALvoid CDECL wine_alDisable(ALenum capability)
 167 {
 168     alDisable(capability);
 169 }
 170
 171 ALboolean CDECL wine_alIsEnabled(ALenum capability)
 172 {
 173     return alIsEnabled(capability);
 174 }
 175
 176 const ALchar* CDECL wine_alGetString(ALenum param)
 177 {
 178     return alGetString(param);
 179 }
 180
 181 ALvoid CDECL wine_alGetBooleanv(ALenum param, ALboolean* data)
 182 {
 183     alGetBooleanv(param, data);
 184 }
 185
 186 ALvoid CDECL wine_alGetIntegerv(ALenum param, ALint* data)
 187 {
 188     alGetIntegerv(param, data);
 189 }
 190
 191 ALvoid CDECL wine_alGetFloatv(ALenum param, ALfloat* data)
 192 {
 193     alGetFloatv(param, data);
 194 }
 195
 196 ALvoid CDECL wine_alGetDoublev(ALenum param, ALdouble* data)
 197 {
 198     alGetDoublev(param, data);
 199 }
 200
 201 ALboolean CDECL wine_alGetBoolean(ALenum param)
 202 {
 203     return alGetBoolean(param);
 204 }
 205
 206 ALint CDECL wine_alGetInteger(ALenum param)
 207 {
 208     return alGetInteger(param);
 209 }
 210
 211 ALfloat CDECL wine_alGetFloat(ALenum param)
 212 {
 213     return alGetFloat(param);
 214 }
 215
 216 ALdouble CDECL wine_alGetDouble(ALenum param)
 217 {
 218     return alGetDouble(param);
 219 }
 220
 221 ALenum CDECL wine_alGetError(ALvoid)
 222 {
 223     return alGetError();
 224 }
 225
 226 ALboolean CDECL wine_alIsExtensionPresent(const ALchar* extname)
 227 {
 228     return alIsExtensionPresent(extname);
 229 }
 230
 231 ALvoid* CDECL wine_alGetProcAddress(const ALchar* funcname)
 232 {
 233     void *proc;
 234     int i;
 235
 236     /* Make sure the host implementation has the requested function. This will
 237      * also set the last AL error properly if the function should not be
 238      * returned (eg. no current context). */
 239     proc = alGetProcAddress(funcname);
 240     if(!proc)
 241         return NULL;
 242
 243     for(i = 0;ALFuncs[i].name;i++)
 244     {
 245         if(strcmp(funcname, ALFuncs[i].name) == 0)
 246             return ALFuncs[i].proc;
 247     }
 248     FIXME("Could not find function in list: %s\n", funcname);
 249     return NULL;
 250 }
 251
 252 ALenum CDECL wine_alGetEnumValue(const ALchar* ename)
 253 {
 254     return alGetEnumValue(ename);
 255 }
 256
 257 ALvoid CDECL wine_alListenerf(ALenum param, ALfloat value)
 258 {
 259     alListenerf(param, value);
 260 }
 261
 262 ALvoid CDECL wine_alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 263 {
 264     alListener3f(param, value1, value2, value3);
 265 }
 266
 267 ALvoid CDECL wine_alListenerfv(ALenum param, const ALfloat* values)
 268 {
 269     alListenerfv(param, values);
 270 }
 271
 272 ALvoid CDECL wine_alListeneri(ALenum param, ALint value)
 273 {
 274     alListeneri(param, value);
 275 }
 276
 277 ALvoid CDECL wine_alGetListenerf(ALenum param, ALfloat* value)
 278 {
 279     alGetListenerf(param, value);
 280 }
 281
 282 ALvoid CDECL wine_alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 283 {
 284     alGetListener3f(param, value1, value2, value3);
 285 }
 286
 287 ALvoid CDECL wine_alGetListenerfv(ALenum param, ALfloat* values)
 288 {
 289     alGetListenerfv(param, values);
 290 }
 291
 292 ALvoid CDECL wine_alGetListeneri(ALenum param, ALint* value)
 293 {
 294     alGetListeneri(param, value);
 295 }
 296
 297 ALvoid CDECL wine_alGetListeneriv(ALenum param, ALint* values)
 298 {
 299     alGetListeneriv(param, values);
 300 }
 301
 302 ALvoid CDECL wine_alGenSources(ALsizei n, ALuint* sources)
 303 {
 304     alGenSources(n, sources);
 305 }
 306
 307 ALvoid CDECL wine_alDeleteSources(ALsizei n, const ALuint* sources)
 308 {
 309     alDeleteSources(n, sources);
 310 }
 311
 312 ALboolean CDECL wine_alIsSource(ALuint sid)
 313 {
 314     return alIsSource(sid);
 315 }
 316
 317 ALvoid CDECL wine_alSourcef(ALuint sid, ALenum param, ALfloat value)
 318 {
 319     alSourcef(sid, param, value);
 320 }
 321
 322 ALvoid CDECL wine_alSource3f(ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 323 {
 324     alSource3f(sid, param, value1, value2, value3);
 325 }
 326
 327 ALvoid CDECL wine_alSourcefv(ALuint sid, ALenum param, const ALfloat* values)
 328 {
 329     alSourcefv(sid, param, values);
 330 }
 331
 332 ALvoid CDECL wine_alSourcei(ALuint sid, ALenum param, ALint value)
 333 {
 334     alSourcei(sid, param, value);
 335 }
 336
 337 ALvoid CDECL wine_alGetSourcef(ALuint sid, ALenum param, ALfloat* value)
 338 {
 339     alGetSourcef(sid, param, value);
 340 }
 341
 342 ALvoid CDECL wine_alGetSource3f(ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
 343 {
 344     alGetSource3f(sid, param, value1, value2, value3);
 345 }
 346
 347 ALvoid CDECL wine_alGetSourcefv(ALuint sid, ALenum param, ALfloat* values)
 348 {
 349     alGetSourcefv(sid, param, values);
 350 }
 351
 352 ALvoid CDECL wine_alGetSourcei(ALuint sid, ALenum param, ALint* value)
 353 {
 354     alGetSourcei(sid, param, value);
 355 }
 356
 357 ALvoid CDECL wine_alGetSourceiv(ALuint sid, ALenum param, ALint* values)
 358 {
 359     alGetSourceiv(sid, param, values);
 360 }
 361
 362 ALvoid CDECL wine_alSourcePlayv(ALsizei ns, const ALuint *sids)
 363 {
 364     alSourcePlayv(ns, sids);
 365 }
 366
 367 ALvoid CDECL wine_alSourceStopv(ALsizei ns, const ALuint *sids)
 368 {
 369     alSourceStopv(ns, sids);
 370 }
 371
 372 ALvoid CDECL wine_alSourceRewindv(ALsizei ns, const ALuint *sids)
 373 {
 374     alSourceRewindv(ns, sids);
 375 }
 376
 377 ALvoid CDECL wine_alSourcePausev(ALsizei ns, const ALuint *sids)
 378 {
 379     alSourcePausev(ns, sids);
 380 }
 381
 382 ALvoid CDECL wine_alSourcePlay(ALuint sid)
 383 {
 384     alSourcePlay(sid);
 385 }
 386
 387 ALvoid CDECL wine_alSourceStop(ALuint sid)
 388 {
 389     alSourceStop(sid);
 390 }
 391
 392 ALvoid CDECL wine_alSourceRewind(ALuint sid)
 393 {
 394     alSourceRewind(sid);
 395 }
 396
 397 ALvoid CDECL wine_alSourcePause(ALuint sid)
 398 {
 399     alSourcePause(sid);
 400 }
 401
 402 ALvoid CDECL wine_alSourceQueueBuffers(ALuint sid, ALsizei numEntries, const ALuint *bids)
 403 {
 404     alSourceQueueBuffers(sid, numEntries, bids);
 405 }
 406
 407 ALvoid CDECL wine_alSourceUnqueueBuffers(ALuint sid, ALsizei numEntries, ALuint *bids)
 408 {
 409     alSourceUnqueueBuffers(sid, numEntries, bids);
 410 }
 411
 412 ALvoid CDECL wine_alGenBuffers(ALsizei n, ALuint* buffers)
 413 {
 414     alGenBuffers(n, buffers);
 415 }
 416
 417 ALvoid CDECL wine_alDeleteBuffers(ALsizei n, const ALuint* buffers)
 418 {
 419     alDeleteBuffers(n, buffers);
 420 }
 421
 422 ALboolean CDECL wine_alIsBuffer(ALuint bid)
 423 {
 424     return alIsBuffer(bid);
 425 }
 426
 427 ALvoid CDECL wine_alBufferData(ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
 428 {
 429     alBufferData(bid, format, data, size, freq);
 430 }
 431
 432 ALvoid CDECL wine_alGetBufferf(ALuint bid, ALenum param, ALfloat* value)
 433 {
 434     alGetBufferf(bid, param, value);
 435 }
 436
 437 ALvoid CDECL wine_alGetBufferfv(ALuint bid, ALenum param, ALfloat* values)
 438 {
 439     alGetBufferfv(bid, param, values);
 440 }
 441
 442 ALvoid CDECL wine_alGetBufferi(ALuint bid, ALenum param, ALint* value)
 443 {
 444     alGetBufferi(bid, param, value);
 445 }
 446
 447 ALvoid CDECL wine_alGetBufferiv(ALuint bid, ALenum param, ALint* values)
 448 {
 449     alGetBufferiv(bid, param, values);
 450 }
 451
 452 ALvoid CDECL wine_alDopplerFactor(ALfloat value)
 453 {
 454     alDopplerFactor(value);
 455 }
 456
 457 ALvoid CDECL wine_alDopplerVelocity(ALfloat value)
 458 {
 459     alDopplerVelocity(value);
 460 }
 461
 462 ALvoid CDECL wine_alDistanceModel(ALenum distanceModel)
 463 {
 464     alDistanceModel(distanceModel);
 465 }
 466
 467
 468 /* OpenAL ALC 1.1 functions */
 469 ALCdevice* CDECL wine_alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize)
 470 {
 471      return alcCaptureOpenDevice(devicename, frequency, format, buffersize);
 472 }
 473
 474 ALCboolean CDECL wine_alcCaptureCloseDevice(ALCdevice *device)
 475 {
 476     return alcCaptureCloseDevice(device);
 477 }
 478
 479 ALCvoid CDECL wine_alcCaptureStart(ALCdevice *device)
 480 {
 481     alcCaptureStart(device);
 482 }
 483
 484 ALCvoid CDECL wine_alcCaptureStop(ALCdevice *device)
 485 {
 486     alcCaptureStop(device);
 487 }
 488
 489 ALCvoid CDECL wine_alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
 490 {
 491     alcCaptureSamples(device, buffer, samples);
 492 }
 493
 494 /* OpenAL 1.1 functions */
 495 ALvoid CDECL wine_alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
 496 {
 497     alListener3i(param, value1, value2, value3);
 498 }
 499
 500 ALvoid CDECL wine_alListeneriv(ALenum param, const ALint* values)
 501 {
 502     alListeneriv(param, values);
 503 }
 504
 505 ALvoid CDECL wine_alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
 506 {
 507     alGetListener3i(param, value1, value2, value3);
 508 }
 509
 510 ALvoid CDECL wine_alSource3i(ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3)
 511 {
 512     alSource3i(sid, param, value1, value2, value3);
 513 }
 514
 515 ALvoid CDECL wine_alSourceiv(ALuint sid, ALenum param, const ALint* values)
 516 {
 517     alSourceiv(sid, param, values);
 518 }
 519
 520 ALvoid CDECL wine_alGetSource3i(ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
 521 {
 522     alGetSource3i(sid, param, value1, value2, value3);
 523 }
 524
 525 ALvoid CDECL wine_alBufferf(ALuint bid, ALenum param, ALfloat value)
 526 {
 527     alBufferf(bid, param, value);
 528 }
 529
 530 ALvoid CDECL wine_alBuffer3f(ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
 531 {
 532     alBuffer3f(bid, param, value1, value2, value3);
 533 }
 534
 535 ALvoid CDECL wine_alBufferfv(ALuint bid, ALenum param, const ALfloat* values)
 536 {
 537     alBufferfv(bid, param, values);
 538 }
 539
 540 ALvoid CDECL wine_alBufferi(ALuint bid, ALenum param, ALint value)
 541 {
 542     alBufferi(bid, param, value);
 543 }
 544
 545 ALvoid CDECL wine_alBuffer3i(ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3)
 546 {
 547     alBuffer3i(bid, param, value1, value2, value3);
 548 }
 549
 550 ALvoid CDECL wine_alBufferiv(ALuint bid, ALenum param, const ALint* values)
 551 {
 552     alBufferiv(bid, param, values);
 553 }
 554
 555 ALvoid CDECL wine_alGetBuffer3f(ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3)
 556 {
 557     alGetBuffer3f(bid, param, value1, value2, value3);
 558 }
 559
 560 ALvoid CDECL wine_alGetBuffer3i(ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3)
 561 {
 562     alGetBuffer3i(bid, param, value1, value2, value3);
 563 }
 564
 565 ALvoid CDECL wine_alSpeedOfSound(ALfloat value)
 566 {
 567     alSpeedOfSound(value);
 568 }
 569
 570 static const struct FuncList ALCFuncs[] = {
 571     { "alcCreateContext",           wine_alcCreateContext        },
 572     { "alcMakeContextCurrent",      wine_alcMakeContextCurrent   },
 573     { "alcProcessContext",          wine_alcProcessContext       },
 574     { "alcSuspendContext",          wine_alcSuspendContext       },
 575     { "alcDestroyContext",          wine_alcDestroyContext       },
 576     { "alcGetCurrentContext",       wine_alcGetCurrentContext    },
 577     { "alcGetContextsDevice",       wine_alcGetContextsDevice    },
 578     { "alcOpenDevice",              wine_alcOpenDevice           },
 579     { "alcCloseDevice",             wine_alcCloseDevice          },
 580     { "alcGetError",                wine_alcGetError             },
 581     { "alcIsExtensionPresent",      wine_alcIsExtensionPresent   },
 582     { "alcGetProcAddress",          wine_alcGetProcAddress       },
 583     { "alcGetEnumValue",            wine_alcGetEnumValue         },
 584     { "alcGetString",               wine_alcGetString            },
 585     { "alcGetIntegerv",             wine_alcGetIntegerv          },
 586     { "alcCaptureOpenDevice",       wine_alcCaptureOpenDevice    },
 587     { "alcCaptureCloseDevice",      wine_alcCaptureCloseDevice   },
 588     { "alcCaptureStart",            wine_alcCaptureStart         },
 589     { "alcCaptureStop",             wine_alcCaptureStop          },
 590     { "alcCaptureSamples",          wine_alcCaptureSamples       },
 591     { NULL,                         NULL                         }
 592 };
 593 static const struct FuncList ALFuncs[] = {
 594     { "alEnable",                   wine_alEnable                },
 595     { "alDisable",                  wine_alDisable               },
 596     { "alIsEnabled",                wine_alIsEnabled             },
 597     { "alGetString",                wine_alGetString             },
 598     { "alGetBooleanv",              wine_alGetBooleanv           },
 599     { "alGetIntegerv",              wine_alGetIntegerv           },
 600     { "alGetFloatv",                wine_alGetFloatv             },
 601     { "alGetDoublev",               wine_alGetDoublev            },
 602     { "alGetBoolean",               wine_alGetBoolean            },
 603     { "alGetInteger",               wine_alGetInteger            },
 604     { "alGetFloat",                 wine_alGetFloat              },
 605     { "alGetDouble",                wine_alGetDouble             },
 606     { "alGetError",                 wine_alGetError              },
 607     { "alIsExtensionPresent",       wine_alIsExtensionPresent    },
 608     { "alGetProcAddress",           wine_alGetProcAddress        },
 609     { "alGetEnumValue",             wine_alGetEnumValue          },
 610     { "alListenerf",                wine_alListenerf             },
 611     { "alListener3f",               wine_alListener3f            },
 612     { "alListenerfv",               wine_alListenerfv            },
 613     { "alListeneri",                wine_alListeneri             },
 614     { "alListener3i",               wine_alListener3i            },
 615     { "alListeneriv",               wine_alListeneriv            },
 616     { "alGetListenerf",             wine_alGetListenerf          },
 617     { "alGetListener3f",            wine_alGetListener3f         },
 618     { "alGetListenerfv",            wine_alGetListenerfv         },
 619     { "alGetListeneri",             wine_alGetListeneri          },
 620     { "alGetListener3i",            wine_alGetListener3i         },
 621     { "alGetListeneriv",            wine_alGetListeneriv         },
 622     { "alGenSources",               wine_alGenSources            },
 623     { "alDeleteSources",            wine_alDeleteSources         },
 624     { "alIsSource",                 wine_alIsSource              },
 625     { "alSourcef",                  wine_alSourcef               },
 626     { "alSource3f",                 wine_alSource3f              },
 627     { "alSourcefv",                 wine_alSourcefv              },
 628     { "alSourcei",                  wine_alSourcei               },
 629     { "alSource3i",                 wine_alSource3i              },
 630     { "alSourceiv",                 wine_alSourceiv              },
 631     { "alGetSourcef",               wine_alGetSourcef            },
 632     { "alGetSource3f",              wine_alGetSource3f           },
 633     { "alGetSourcefv",              wine_alGetSourcefv           },
 634     { "alGetSourcei",               wine_alGetSourcei            },
 635     { "alGetSource3i",              wine_alGetSource3i           },
 636     { "alGetSourceiv",              wine_alGetSourceiv           },
 637     { "alSourcePlayv",              wine_alSourcePlayv           },
 638     { "alSourceStopv",              wine_alSourceStopv           },
 639     { "alSourceRewindv",            wine_alSourceRewindv         },
 640     { "alSourcePausev",             wine_alSourcePausev          },
 641     { "alSourcePlay",               wine_alSourcePlay            },
 642     { "alSourceStop",               wine_alSourceStop            },
 643     { "alSourceRewind",             wine_alSourceRewind          },
 644     { "alSourcePause",              wine_alSourcePause           },
 645     { "alSourceQueueBuffers",       wine_alSourceQueueBuffers    },
 646     { "alSourceUnqueueBuffers",     wine_alSourceUnqueueBuffers  },
 647     { "alGenBuffers",               wine_alGenBuffers            },
 648     { "alDeleteBuffers",            wine_alDeleteBuffers         },
 649     { "alIsBuffer",                 wine_alIsBuffer              },
 650     { "alBufferData",               wine_alBufferData            },
 651     { "alBufferf",                  wine_alBufferf               },
 652     { "alBuffer3f",                 wine_alBuffer3f              },
 653     { "alBufferfv",                 wine_alBufferfv              },
 654     { "alBufferi",                  wine_alBufferi               },
 655     { "alBuffer3i",                 wine_alBuffer3i              },
 656     { "alBufferiv",                 wine_alBufferiv              },
 657     { "alGetBufferf",               wine_alGetBufferf            },
 658     { "alGetBuffer3f",              wine_alGetBuffer3f           },
 659     { "alGetBufferfv",              wine_alGetBufferfv           },
 660     { "alGetBufferi",               wine_alGetBufferi            },
 661     { "alGetBuffer3i",              wine_alGetBuffer3i           },
 662     { "alGetBufferiv",              wine_alGetBufferiv           },
 663     { "alDopplerFactor",            wine_alDopplerFactor         },
 664     { "alDopplerVelocity",          wine_alDopplerVelocity       },
 665     { "alSpeedOfSound",             wine_alSpeedOfSound          },
 666     { "alDistanceModel",            wine_alDistanceModel         },
 667     { NULL,                         NULL                         }
 668 };