Router/al.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2003 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21
  22
  23
  24 #include <al\alc.h>
  25 #include "OpenAL32.h"
  26
  27 typedef struct ALfunction_struct
  28 {
  29         ALchar          *funcName;
  30         ALvoid          *address;
  31 } ALfunction;
  32
  33 static ALfunction  function[]=   {
  34         { "alEnable",                   (ALvoid *) alEnable                  },
  35         { "alDisable",                  (ALvoid *) alDisable                 },
  36         { "alIsEnabled",                (ALvoid *) alIsEnabled               },
  37         { "alGetString",                (ALvoid *) alGetString               },
  38         { "alGetBooleanv",              (ALvoid *) alGetBooleanv             },
  39         { "alGetIntegerv",              (ALvoid *) alGetIntegerv             },
  40         { "alGetFloatv",                (ALvoid *) alGetFloatv               },
  41         { "alGetDoublev",               (ALvoid *) alGetDoublev              },
  42         { "alGetBoolean",               (ALvoid *) alGetBoolean              },
  43         { "alGetInteger",               (ALvoid *) alGetInteger              },
  44         { "alGetFloat",                 (ALvoid *) alGetFloat                },
  45         { "alGetDouble",                (ALvoid *) alGetDouble               },
  46         { "alGetError",                 (ALvoid *) alGetError                },
  47         { "alIsExtensionPresent",       (ALvoid *) alIsExtensionPresent      },
  48         { "alGetProcAddress",           (ALvoid *) alGetProcAddress          },
  49         { "alGetEnumValue",             (ALvoid *) alGetEnumValue            },
  50         { "alListenerf",                (ALvoid *) alListenerf               },
  51         { "alListener3f",               (ALvoid *) alListener3f              },
  52         { "alListenerfv",               (ALvoid *) alListenerfv              },
  53         { "alListeneri",                (ALvoid *) alListeneri               },
  54         { "alListener3i",               (ALvoid *) alListener3i              },
  55         { "alListeneriv",               (ALvoid *) alListeneriv              },
  56         { "alGetListenerf",             (ALvoid *) alGetListenerf            },
  57         { "alGetListener3f",            (ALvoid *) alGetListener3f           },
  58         { "alGetListenerfv",            (ALvoid *) alGetListenerfv           },
  59         { "alGetListeneri",             (ALvoid *) alGetListeneri            },
  60         { "alGetListener3i",            (ALvoid *) alGetListener3i           },
  61         { "alGetListeneriv",            (ALvoid *) alGetListeneriv           },
  62         { "alGenSources",               (ALvoid *) alGenSources              },
  63         { "alDeleteSources",            (ALvoid *) alDeleteSources           },
  64         { "alIsSource",                 (ALvoid *) alIsSource                },
  65         { "alSourcef",                  (ALvoid *) alSourcef                 },
  66         { "alSource3f",                 (ALvoid *) alSource3f                },
  67         { "alSourcefv",                 (ALvoid *) alSourcefv                },
  68         { "alSourcei",                  (ALvoid *) alSourcei                 },
  69         { "alSource3i",                 (ALvoid *) alSource3i                },
  70         { "alSourceiv",                 (ALvoid *) alSourceiv                },
  71         { "alGetSourcef",               (ALvoid *) alGetSourcef              },
  72         { "alGetSource3f",              (ALvoid *) alGetSource3f             },
  73         { "alGetSourcefv",              (ALvoid *) alGetSourcefv             },
  74         { "alGetSourcei",               (ALvoid *) alGetSourcei              },
  75         { "alGetSource3i",              (ALvoid *) alGetSource3i             },
  76         { "alGetSourceiv",              (ALvoid *) alGetSourceiv             },
  77         { "alSourcePlayv",              (ALvoid *) alSourcePlayv             },
  78         { "alSourceStopv",              (ALvoid *) alSourceStopv             },
  79         { "alSourceRewindv",            (ALvoid *) alSourceRewindv           },
  80         { "alSourcePausev",             (ALvoid *) alSourcePausev            },
  81         { "alSourcePlay",               (ALvoid *) alSourcePlay              },
  82         { "alSourceStop",               (ALvoid *) alSourceStop              },
  83         { "alSourceRewind",             (ALvoid *) alSourceRewind            },
  84         { "alSourcePause",              (ALvoid *) alSourcePause             },
  85         { "alSourceQueueBuffers",       (ALvoid *) alSourceQueueBuffers      },
  86         { "alSourceUnqueueBuffers",     (ALvoid *) alSourceUnqueueBuffers    },
  87         { "alGenBuffers",               (ALvoid *) alGenBuffers              },
  88         { "alDeleteBuffers",            (ALvoid *) alDeleteBuffers           },
  89         { "alIsBuffer",                 (ALvoid *) alIsBuffer                },
  90         { "alBufferData",               (ALvoid *) alBufferData              },
  91         { "alBufferf",                  (ALvoid *) alBufferf                 },
  92         { "alBuffer3f",                 (ALvoid *) alBuffer3f                },
  93         { "alBufferfv",                 (ALvoid *) alBufferfv                },
  94         { "alBufferi",                  (ALvoid *) alBufferi                 },
  95         { "alBuffer3i",                 (ALvoid *) alBuffer3i                },
  96         { "alBufferiv",                 (ALvoid *) alBufferiv                },
  97         { "alGetBufferf",               (ALvoid *) alGetBufferf              },
  98         { "alGetBuffer3f",              (ALvoid *) alGetBuffer3f             },
  99         { "alGetBufferfv",              (ALvoid *) alGetBufferfv             },
 100         { "alGetBufferi",               (ALvoid *) alGetBufferi              },
 101         { "alGetBuffer3i",              (ALvoid *) alGetBuffer3i             },
 102         { "alGetBufferiv",              (ALvoid *) alGetBufferiv             },
 103         { "alDopplerFactor",            (ALvoid *) alDopplerFactor           },
 104         { "alDopplerVelocity",          (ALvoid *) alDopplerVelocity         },
 105         { "alSpeedOfSound",             (ALvoid *) alSpeedOfSound            },
 106         { "alDistanceModel",            (ALvoid *) alDistanceModel           },
 107         { NULL,                                                 (ALvoid *) NULL                      } };
 108
 109
 110 //*****************************************************************************
 111 //*****************************************************************************
 112 //
 113 // Defines
 114 //
 115 //*****************************************************************************
 116 //*****************************************************************************
 117
 118
 119 #ifdef __MINGW32__
 120 // fix for Mingw32.
 121 #define AL_VOID_FXN(fxn)                                                    \
 122     ALCcontext* context;                                                     \
 123                                                                             \
 124     alListAcquireLock(alContextList);                                       \
 125     if(!alCurrentContext)                                                   \
 126     {                                                                       \
 127         alListReleaseLock(alContextList);                                   \
 128         return;                                                             \
 129     }                                                                       \
 130                                                                             \
 131     context = alCurrentContext;                                             \
 132     EnterCriticalSection(&context->Lock);                                   \
 133     alListReleaseLock(alContextList);                                       \
 134                                                                             \
 135     context->AlApi.fxn;                                                   \
 136     LeaveCriticalSection(&context->Lock);                                   \
 137     return
 138 #define AL_RESULT_FXN(fxn, resultType, resultDefVal)                        \
 139     resultType result = resultDefVal;                                       \
 140     ALCcontext* context;                                                     \
 141                                                                             \
 142     alListAcquireLock(alContextList);                                       \
 143     if(!alCurrentContext)                                                   \
 144     {                                                                       \
 145         alListReleaseLock(alContextList);                                   \
 146         return result;                                                      \
 147     }                                                                       \
 148                                                                             \
 149     context = alCurrentContext;                                             \
 150     EnterCriticalSection(&context->Lock);                                   \
 151     alListReleaseLock(alContextList);                                       \
 152                                                                             \
 153     result = context->AlApi.fxn;                                          \
 154     LeaveCriticalSection(&context->Lock);                                   \
 155     return result
 156
 157 #else
 158 #define AL_RESULT_FXN(fxn, resultType, resultDefVal)                        \
 159     resultType result = resultDefVal;                                       \
 160     ALCcontext* context;                                                     \
 161                                                                             \
 162     alListAcquireLock(alContextList);                                       \
 163     if(!alCurrentContext)                                                   \
 164     {                                                                       \
 165         alListReleaseLock(alContextList);                                   \
 166         return result;                                                      \
 167     }                                                                       \
 168                                                                             \
 169     context = alCurrentContext;                                             \
 170     EnterCriticalSection(&context->Lock);                                   \
 171     alListReleaseLock(alContextList);                                       \
 172                                                                             \
 173     result = context->AlApi.##fxn;                                          \
 174     LeaveCriticalSection(&context->Lock);                                   \
 175     return result
 176
 177 #define AL_VOID_FXN(fxn)                                                    \
 178     ALCcontext* context;                                                     \
 179                                                                             \
 180     alListAcquireLock(alContextList);                                       \
 181     if(!alCurrentContext)                                                   \
 182     {                                                                       \
 183         alListReleaseLock(alContextList);                                   \
 184         return;                                                             \
 185     }                                                                       \
 186                                                                             \
 187     context = alCurrentContext;                                             \
 188     EnterCriticalSection(&context->Lock);                                   \
 189     alListReleaseLock(alContextList);                                       \
 190                                                                             \
 191     context->AlApi.##fxn;                                                   \
 192     LeaveCriticalSection(&context->Lock);                                   \
 193     return
 194 #endif
 195
 196
 197 //*****************************************************************************
 198 //*****************************************************************************
 199 //
 200 // AL API Buffer Entry Points
 201 //
 202 //*****************************************************************************
 203 //*****************************************************************************
 204
 205 //*****************************************************************************
 206 // alGenBuffers
 207 //*****************************************************************************
 208 //
 209 ALAPI ALvoid ALAPIENTRY alGenBuffers(ALsizei n, ALuint* bufferNames)
 210 {
 211     AL_VOID_FXN(alGenBuffers(n, bufferNames));
 212 }
 213
 214
 215 //*****************************************************************************
 216 // alDeleteBuffers
 217 //*****************************************************************************
 218 //
 219 ALAPI ALvoid ALAPIENTRY alDeleteBuffers(ALsizei n, const ALuint* bufferNames)
 220 {
 221     AL_VOID_FXN(alDeleteBuffers(n, bufferNames));
 222 }
 223
 224
 225 //*****************************************************************************
 226 // alIsBuffer
 227 //*****************************************************************************
 228 //
 229 ALAPI ALboolean ALAPIENTRY alIsBuffer(ALuint bufferName)
 230 {
 231     AL_RESULT_FXN(alIsBuffer(bufferName), ALboolean, AL_FALSE);
 232 }
 233
 234 //*****************************************************************************
 235 // alBuffer3f
 236 //*****************************************************************************
 237 //
 238 ALAPI ALvoid ALAPIENTRY alBuffer3f(ALuint bufferName, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3)
 239 {
 240     AL_VOID_FXN(alBuffer3f(bufferName, param, v1, v2, v3));
 241 }
 242
 243 //*****************************************************************************
 244 // alBuffer3i
 245 //*****************************************************************************
 246 //
 247 ALAPI ALvoid ALAPIENTRY alBuffer3i(ALuint bufferName, ALenum param, ALint v1, ALint v2, ALint v3)
 248 {
 249     AL_VOID_FXN(alBuffer3i(bufferName, param, v1, v2, v3));
 250 }
 251
 252
 253 //*****************************************************************************
 254 // alBufferData
 255 //*****************************************************************************
 256 //
 257 ALAPI ALvoid ALAPIENTRY alBufferData(ALuint bufferName, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq)
 258 {
 259     AL_VOID_FXN(alBufferData(bufferName, format, data, size, freq));
 260 }
 261
 262
 263 //*****************************************************************************
 264 // alBufferf
 265 //*****************************************************************************
 266 //
 267 ALAPI ALvoid ALAPIENTRY alBufferf(ALuint bufferName, ALenum param, ALfloat value)
 268 {
 269     AL_VOID_FXN(alBufferf(bufferName, param, value));
 270 }
 271
 272
 273 //*****************************************************************************
 274 // alBufferfv
 275 //*****************************************************************************
 276 //
 277 ALAPI ALvoid ALAPIENTRY alBufferfv(ALuint bufferName, ALenum param, const ALfloat* values)
 278 {
 279     AL_VOID_FXN(alBufferfv(bufferName, param, values));
 280 }
 281
 282
 283 //*****************************************************************************
 284 // alBufferi
 285 //*****************************************************************************
 286 //
 287 ALAPI ALvoid ALAPIENTRY alBufferi(ALuint bufferName, ALenum param, ALint value)
 288 {
 289     AL_VOID_FXN(alBufferi(bufferName, param, value));
 290 }
 291
 292
 293 //*****************************************************************************
 294 // alBufferiv
 295 //*****************************************************************************
 296 //
 297 ALAPI ALvoid ALAPIENTRY alBufferiv(ALuint bufferName, ALenum param, const ALint* values)
 298 {
 299     AL_VOID_FXN(alBufferiv(bufferName, param, values));
 300 }
 301
 302 //*****************************************************************************
 303 // alGetBuffer3f
 304 //*****************************************************************************
 305 //
 306 ALAPI ALvoid ALAPIENTRY alGetBuffer3f(ALuint bufferName, ALenum param, ALfloat *v1, ALfloat *v2, ALfloat *v3)
 307 {
 308     AL_VOID_FXN(alGetBuffer3f(bufferName, param, v1, v2, v3));
 309 }
 310
 311 //*****************************************************************************
 312 // alGetBuffer3i
 313 //*****************************************************************************
 314 //
 315 ALAPI ALvoid ALAPIENTRY alGetBuffer3i(ALuint bufferName, ALenum param, ALint *v1, ALint *v2, ALint *v3)
 316 {
 317     AL_VOID_FXN(alGetBuffer3i(bufferName, param, v1, v2, v3));
 318 }
 319
 320 //*****************************************************************************
 321 // alGetBufferf
 322 //*****************************************************************************
 323 //
 324 ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint bufferName, ALenum param, ALfloat* value)
 325 {
 326     AL_VOID_FXN(alGetBufferf(bufferName, param, value));
 327 }
 328
 329 //*****************************************************************************
 330 // alGetBufferfv
 331 //*****************************************************************************
 332 //
 333 ALAPI ALvoid ALAPIENTRY alGetBufferfv(ALuint bufferName, ALenum param, ALfloat* values)
 334 {
 335     AL_VOID_FXN(alGetBufferfv(bufferName, param, values));
 336 }
 337
 338
 339 //*****************************************************************************
 340 // alGetBufferi
 341 //*****************************************************************************
 342 //
 343 ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint bufferName, ALenum param, ALint* value)
 344 {
 345     AL_VOID_FXN(alGetBufferi(bufferName, param, value));
 346 }
 347
 348 //*****************************************************************************
 349 // alGetBufferiv
 350 //*****************************************************************************
 351 //
 352 ALAPI ALvoid ALAPIENTRY alGetBufferiv(ALuint bufferName, ALenum param, ALint* values)
 353 {
 354     AL_VOID_FXN(alGetBufferiv(bufferName, param, values));
 355 }
 356
 357
 358 //*****************************************************************************
 359 //*****************************************************************************
 360 //
 361 // AL API Generic Entry Points
 362 //
 363 //*****************************************************************************
 364 //*****************************************************************************
 365
 366 //*****************************************************************************
 367 // alEnable
 368 //*****************************************************************************
 369 //
 370 ALAPI ALvoid ALAPIENTRY alEnable(ALenum capability)
 371 {
 372     AL_VOID_FXN(alEnable(capability));
 373 }
 374
 375
 376 //*****************************************************************************
 377 // alDisable
 378 //*****************************************************************************
 379 //
 380 ALAPI ALvoid ALAPIENTRY alDisable(ALenum capability)
 381 {
 382     AL_VOID_FXN(alDisable(capability));
 383 }
 384
 385
 386 //*****************************************************************************
 387 // alDopplerFactor
 388 //*****************************************************************************
 389 //
 390 ALAPI ALvoid ALAPIENTRY alDopplerFactor(ALfloat value)
 391 {
 392     AL_VOID_FXN(alDopplerFactor(value));
 393 }
 394
 395
 396 //*****************************************************************************
 397 // alDopplerVelocity
 398 //*****************************************************************************
 399 //
 400 ALAPI ALvoid ALAPIENTRY alDopplerVelocity(ALfloat value)
 401 {
 402     AL_VOID_FXN(alDopplerVelocity(value));
 403 }
 404
 405
 406 //*****************************************************************************
 407 // alSpeedOfSound
 408 //*****************************************************************************
 409 //
 410 ALAPI ALvoid ALAPIENTRY alSpeedOfSound(ALfloat value)
 411 {
 412     ALCcontext* context;
 413
 414     alListAcquireLock(alContextList);
 415     if(!alCurrentContext)
 416     {
 417         alListReleaseLock(alContextList);
 418         return;
 419     }
 420
 421     context = alCurrentContext;
 422     EnterCriticalSection(&context->Lock);
 423     alListReleaseLock(alContextList);
 424
 425         if (context->AlApi.alSpeedOfSound) { // protect against talking to a 1.0 lib
 426                 context->AlApi.alSpeedOfSound(value);
 427         }
 428     LeaveCriticalSection(&context->Lock);
 429     return;
 430 }
 431
 432
 433 //*****************************************************************************
 434 // alDistanceModel
 435 //*****************************************************************************
 436 //
 437 ALAPI ALvoid ALAPIENTRY alDistanceModel(ALenum value)
 438 {
 439     AL_VOID_FXN(alDistanceModel(value));
 440 }
 441
 442
 443 //*****************************************************************************
 444 // alGetBoolean
 445 //*****************************************************************************
 446 //
 447 ALAPI ALboolean ALAPIENTRY alGetBoolean(ALenum param)
 448 {
 449     AL_RESULT_FXN(alGetBoolean(param), ALboolean, AL_FALSE);
 450 }
 451
 452
 453 //*****************************************************************************
 454 // alGetBooleanv
 455 //*****************************************************************************
 456 //
 457 ALAPI ALvoid ALAPIENTRY alGetBooleanv(ALenum param, ALboolean* data)
 458 {
 459     AL_VOID_FXN(alGetBooleanv(param, data));
 460 }
 461
 462
 463 //*****************************************************************************
 464 // alGetDouble
 465 //*****************************************************************************
 466 //
 467 ALAPI ALdouble ALAPIENTRY alGetDouble(ALenum param)
 468 {
 469     AL_RESULT_FXN(alGetDouble(param), ALdouble, 0.0);
 470 }
 471
 472
 473 //*****************************************************************************
 474 // alGetDoublev
 475 //*****************************************************************************
 476 //
 477 ALAPI ALvoid ALAPIENTRY alGetDoublev(ALenum param, ALdouble* data)
 478 {
 479     AL_VOID_FXN(alGetDoublev(param, data));
 480 }
 481
 482 //*****************************************************************************
 483 // alGetFloat
 484 //*****************************************************************************
 485 //
 486 ALAPI ALfloat ALAPIENTRY alGetFloat(ALenum param)
 487 {
 488     AL_RESULT_FXN(alGetFloat(param), ALfloat, 0.0f);
 489 }
 490
 491
 492 //*****************************************************************************
 493 // alGetFloatv
 494 //*****************************************************************************
 495 //
 496 ALAPI ALvoid ALAPIENTRY alGetFloatv(ALenum param, ALfloat* data)
 497 {
 498     AL_VOID_FXN(alGetFloatv(param, data));
 499 }
 500
 501
 502 //*****************************************************************************
 503 // alGetInteger
 504 //*****************************************************************************
 505 //
 506 ALAPI ALint ALAPIENTRY alGetInteger(ALenum param)
 507 {
 508     AL_RESULT_FXN(alGetInteger(param), ALint, 0);
 509 }
 510
 511
 512 //*****************************************************************************
 513 // alGetIntegerv
 514 //*****************************************************************************
 515 //
 516 ALAPI ALvoid ALAPIENTRY alGetIntegerv(ALenum param, ALint* data)
 517 {
 518     AL_VOID_FXN(alGetIntegerv(param, data));
 519 }
 520
 521
 522 //*****************************************************************************
 523 // alGetEnumValue
 524 //*****************************************************************************
 525 //
 526 ALAPI ALenum ALAPIENTRY alGetEnumValue(const ALCchar* ename)
 527 {
 528     AL_RESULT_FXN(alGetEnumValue(ename), ALenum, AL_INVALID_ENUM);
 529 }
 530
 531
 532 //*****************************************************************************
 533 // alGetError
 534 //*****************************************************************************
 535 //
 536 ALAPI ALenum ALAPIENTRY alGetError(ALvoid)
 537 {
 538     AL_RESULT_FXN(alGetError(), ALenum, AL_NO_ERROR);
 539 }
 540
 541
 542 //*****************************************************************************
 543 // alGetProcAddress
 544 //*****************************************************************************
 545 //
 546 ALAPI ALvoid* ALAPIENTRY alGetProcAddress(const ALCchar* fname)
 547 {
 548         // return router's address if available
 549         ALsizei i=0;
 550         ALvoid *pAddress;
 551
 552         while ((function[i].funcName)&&(strcmp((char *)function[i].funcName,(char *)fname)))
 553                 i++;
 554         pAddress = function[i].address;
 555
 556         if (pAddress != NULL) {
 557                 return pAddress;
 558         }
 559
 560         // router doesn't have this entry point, so go to the device...
 561         AL_RESULT_FXN(alGetProcAddress(fname), ALvoid*, 0);
 562
 563         return pAddress;
 564 }
 565
 566
 567 //*****************************************************************************
 568 // alGetString
 569 //*****************************************************************************
 570 //
 571 ALAPI const ALCchar* ALAPIENTRY alGetString(ALenum param)
 572 {
 573     AL_RESULT_FXN(alGetString(param), const ALCchar*, 0);
 574 }
 575
 576
 577 //*****************************************************************************
 578 // alIsExtensionPresent
 579 //*****************************************************************************
 580 //
 581 ALAPI ALboolean ALAPIENTRY alIsExtensionPresent(const ALCchar* ename)
 582 {
 583     AL_RESULT_FXN(alIsExtensionPresent(ename), ALboolean, AL_FALSE);
 584 }
 585
 586
 587 //*****************************************************************************
 588 // alIsEnabled
 589 //*****************************************************************************
 590 //
 591 ALAPI ALboolean ALAPIENTRY alIsEnabled(ALenum capability)
 592 {
 593     AL_RESULT_FXN(alIsEnabled(capability), ALboolean, AL_FALSE);
 594 }
 595
 596
 597
 598 //*****************************************************************************
 599 //*****************************************************************************
 600 //
 601 // AL API Listener Entry Points
 602 //
 603 //*****************************************************************************
 604 //*****************************************************************************
 605
 606 //*****************************************************************************
 607 // alListenerf
 608 //*****************************************************************************
 609 //
 610 ALAPI ALvoid ALAPIENTRY alListenerf(ALenum param, ALfloat value)
 611 {
 612     AL_VOID_FXN(alListenerf(param, value));
 613 }
 614
 615
 616 //*****************************************************************************
 617 // alListener3f
 618 //*****************************************************************************
 619 //
 620 ALAPI ALvoid ALAPIENTRY alListener3f(ALenum param, ALfloat v1, ALfloat v2, ALfloat v3)
 621 {
 622     AL_VOID_FXN(alListener3f(param, v1, v2, v3));
 623 }
 624
 625
 626 //*****************************************************************************
 627 // alListener3i
 628 //*****************************************************************************
 629 //
 630 ALAPI ALvoid ALAPIENTRY alListener3i(ALenum param, ALint v1, ALint v2, ALint v3)
 631 {
 632     AL_VOID_FXN(alListener3i(param, v1, v2, v3));
 633 }
 634
 635
 636 //*****************************************************************************
 637 // alListenerfv
 638 //*****************************************************************************
 639 //
 640 ALAPI ALvoid ALAPIENTRY alListenerfv(ALenum param, const ALfloat* values)
 641 {
 642     AL_VOID_FXN(alListenerfv(param, values));
 643 }
 644
 645
 646 //*****************************************************************************
 647 // alListeneri
 648 //*****************************************************************************
 649 //
 650 ALAPI ALvoid ALAPIENTRY alListeneri(ALenum param, ALint value)
 651 {
 652     AL_VOID_FXN(alListeneri(param, value));
 653 }
 654
 655
 656 //*****************************************************************************
 657 // alListeneriv
 658 //*****************************************************************************
 659 //
 660 ALAPI ALvoid ALAPIENTRY alListeneriv(ALenum param, const ALint *values)
 661 {
 662     AL_VOID_FXN(alListeneriv(param, values));
 663 }
 664
 665
 666 //*****************************************************************************
 667 // alGetListenerf
 668 //*****************************************************************************
 669 //
 670 ALAPI ALvoid ALAPIENTRY alGetListenerf(ALenum param, ALfloat* value)
 671 {
 672     AL_VOID_FXN(alGetListenerf(param, value));
 673 }
 674
 675
 676 //*****************************************************************************
 677 // alGetListener3f
 678 //*****************************************************************************
 679 //
 680 ALAPI ALvoid ALAPIENTRY alGetListener3f(ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3)
 681 {
 682     AL_VOID_FXN(alGetListener3f(param, v1, v2, v3));
 683 }
 684
 685
 686 //*****************************************************************************
 687 // alGetListener3i
 688 //*****************************************************************************
 689 //
 690 ALAPI ALvoid ALAPIENTRY alGetListener3i(ALenum param, ALint* v1, ALint* v2, ALint* v3)
 691 {
 692     AL_VOID_FXN(alGetListener3i(param, v1, v2, v3));
 693 }
 694
 695
 696 //*****************************************************************************
 697 // alGetListenerfv
 698 //*****************************************************************************
 699 //
 700 ALAPI ALvoid ALAPIENTRY alGetListenerfv(ALenum param, ALfloat* values)
 701 {
 702     AL_VOID_FXN(alGetListenerfv(param, values));
 703 }
 704
 705
 706 //*****************************************************************************
 707 // alGetListeneri
 708 //*****************************************************************************
 709 //
 710 ALAPI ALvoid ALAPIENTRY alGetListeneri(ALenum param, ALint* value)
 711 {
 712     AL_VOID_FXN(alGetListeneri(param, value));
 713 }
 714
 715
 716 //*****************************************************************************
 717 // alGetListeneriv
 718 //*****************************************************************************
 719 //
 720 ALAPI ALvoid ALAPIENTRY alGetListeneriv(ALenum param, ALint* values)
 721 {
 722     AL_VOID_FXN(alGetListeneriv(param, values));
 723 }
 724
 725
 726 //*****************************************************************************
 727 //*****************************************************************************
 728 //
 729 // AL API Source Entry Points
 730 //
 731 //*****************************************************************************
 732 //*****************************************************************************
 733
 734
 735 //*****************************************************************************
 736 // alGenSources
 737 //*****************************************************************************
 738 //
 739 ALAPI ALvoid ALAPIENTRY alGenSources(ALsizei n, ALuint* sourceNames)
 740 {
 741     AL_VOID_FXN(alGenSources(n, sourceNames));
 742 }
 743
 744
 745 //*****************************************************************************
 746 // alDeleteSources
 747 //*****************************************************************************
 748 //
 749 ALAPI ALvoid ALAPIENTRY alDeleteSources(ALsizei n, const ALuint* sourceNames)
 750 {
 751     AL_VOID_FXN(alDeleteSources(n, sourceNames));
 752 }
 753
 754
 755 //*****************************************************************************
 756 // alIsSource
 757 //*****************************************************************************
 758 //
 759 ALAPI ALboolean ALAPIENTRY alIsSource(ALuint sourceName)
 760 {
 761     AL_RESULT_FXN(alIsSource(sourceName), ALboolean, AL_FALSE);
 762 }
 763
 764
 765 //*****************************************************************************
 766 // alSourcef
 767 //*****************************************************************************
 768 //
 769 ALAPI ALvoid ALAPIENTRY alSourcef(ALuint sourceName, ALenum param, ALfloat value)
 770 {
 771     AL_VOID_FXN(alSourcef(sourceName, param, value));
 772 }
 773
 774
 775 //*****************************************************************************
 776 // alSourcefv
 777 //*****************************************************************************
 778 //
 779 ALAPI ALvoid ALAPIENTRY alSourcefv(ALuint sourceName, ALenum param, const ALfloat* values)
 780 {
 781     AL_VOID_FXN(alSourcefv(sourceName, param, values));
 782 }
 783
 784
 785 //*****************************************************************************
 786 // alSource3f
 787 //*****************************************************************************
 788 //
 789 ALAPI ALvoid ALAPIENTRY alSource3f(ALuint sourceName, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3)
 790 {
 791     AL_VOID_FXN(alSource3f(sourceName, param, v1, v2, v3));
 792 }
 793
 794
 795 //*****************************************************************************
 796 // alSource3i
 797 //*****************************************************************************
 798 //
 799 ALAPI ALvoid ALAPIENTRY alSource3i(ALuint sourceName, ALenum param, ALint v1, ALint v2, ALint v3)
 800 {
 801     AL_VOID_FXN(alSource3i(sourceName, param, v1, v2, v3));
 802 }
 803
 804
 805 //*****************************************************************************
 806 // alSourcei
 807 //*****************************************************************************
 808 //
 809 ALAPI ALvoid ALAPIENTRY alSourcei(ALuint sourceName, ALenum param, ALint value)
 810 {
 811     AL_VOID_FXN(alSourcei(sourceName, param, value));
 812 }
 813
 814 //*****************************************************************************
 815 // alSourceiv
 816 //*****************************************************************************
 817 //
 818 ALAPI ALvoid ALAPIENTRY alSourceiv(ALuint sourceName, ALenum param, const ALint* values)
 819 {
 820     AL_VOID_FXN(alSourceiv(sourceName, param, values));
 821 }
 822
 823
 824 //*****************************************************************************
 825 // alGetSourcef
 826 //*****************************************************************************
 827 //
 828 ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint sourceName, ALenum param, ALfloat* value)
 829 {
 830     AL_VOID_FXN(alGetSourcef(sourceName, param, value));
 831 }
 832
 833 //*****************************************************************************
 834 // alGetSource3f
 835 //*****************************************************************************
 836 //
 837 ALAPI ALvoid ALAPIENTRY alGetSource3f(ALuint sourceName, ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3)
 838 {
 839     AL_VOID_FXN(alGetSource3f(sourceName, param, v1, v2, v3));
 840 }
 841
 842
 843 //*****************************************************************************
 844 // alGetSource3i
 845 //*****************************************************************************
 846 //
 847 ALAPI ALvoid ALAPIENTRY alGetSource3i(ALuint sourceName, ALenum param, ALint* v1, ALint* v2, ALint* v3)
 848 {
 849     AL_VOID_FXN(alGetSource3i(sourceName, param, v1, v2, v3));
 850 }
 851
 852
 853 //*****************************************************************************
 854 // alGetSourcefv
 855 //*****************************************************************************
 856 //
 857 ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint sourceName, ALenum param, ALfloat* values)
 858 {
 859     AL_VOID_FXN(alGetSourcefv(sourceName, param, values));
 860 }
 861
 862
 863 //*****************************************************************************
 864 // alGetSourcei
 865 //*****************************************************************************
 866 //
 867 ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint sourceName, ALenum param, ALint* value)
 868 {
 869     AL_VOID_FXN(alGetSourcei(sourceName, param, value));
 870 }
 871
 872
 873 //*****************************************************************************
 874 // alGetSourceiv
 875 //*****************************************************************************
 876 //
 877 ALAPI ALvoid ALAPIENTRY alGetSourceiv(ALuint sourceName, ALenum param, ALint* values)
 878 {
 879     AL_VOID_FXN(alGetSourceiv(sourceName, param, values));
 880 }
 881
 882
 883 //*****************************************************************************
 884 // alSourcePlay
 885 //*****************************************************************************
 886 //
 887 ALAPI ALvoid ALAPIENTRY alSourcePlay(ALuint sourceName)
 888 {
 889     AL_VOID_FXN(alSourcePlay(sourceName));
 890 }
 891
 892
 893 //*****************************************************************************
 894 // alSourcePlayv
 895 //*****************************************************************************
 896 //
 897 ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint* sourceNames)
 898 {
 899     AL_VOID_FXN(alSourcePlayv(n, sourceNames));
 900 }
 901
 902
 903 //*****************************************************************************
 904 // alSourcePause
 905 //*****************************************************************************
 906 //
 907 ALAPI ALvoid ALAPIENTRY alSourcePause(ALuint sourceName)
 908 {
 909     AL_VOID_FXN(alSourcePause(sourceName));
 910 }
 911
 912
 913 //*****************************************************************************
 914 // alSourcePausev
 915 //*****************************************************************************
 916 //
 917 ALAPI ALvoid ALAPIENTRY alSourcePausev(ALsizei n, const ALuint* sourceNames)
 918 {
 919     AL_VOID_FXN(alSourcePausev(n, sourceNames));
 920 }
 921
 922
 923 //*****************************************************************************
 924 // alSourceStop
 925 //*****************************************************************************
 926 //
 927 ALAPI ALvoid ALAPIENTRY alSourceStop(ALuint sourceName)
 928 {
 929     AL_VOID_FXN(alSourceStop(sourceName));
 930 }
 931
 932
 933 //*****************************************************************************
 934 // alSourceStopv
 935 //*****************************************************************************
 936 //
 937 ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint* sourceNames)
 938 {
 939     AL_VOID_FXN(alSourceStopv(n, sourceNames));
 940 }
 941
 942
 943 //*****************************************************************************
 944 // alSourceRewind
 945 //*****************************************************************************
 946 //
 947 ALAPI ALvoid ALAPIENTRY alSourceRewind(ALuint sourceName)
 948 {
 949     AL_VOID_FXN(alSourceRewind(sourceName));
 950 }
 951
 952
 953 //*****************************************************************************
 954 // alSourceRewindv
 955 //*****************************************************************************
 956 //
 957 ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n, const ALuint* sourceNames)
 958 {
 959     AL_VOID_FXN(alSourceRewindv(n, sourceNames));
 960 }
 961
 962
 963 //*****************************************************************************
 964 // alSourceQueueBuffers
 965 //*****************************************************************************
 966 //
 967 ALAPI ALvoid ALAPIENTRY alSourceQueueBuffers(ALuint sourceName, ALsizei n, const ALuint* buffers)
 968 {
 969     AL_VOID_FXN(alSourceQueueBuffers(sourceName, n, buffers));
 970 }
 971
 972
 973 //*****************************************************************************
 974 // alSourceUnqueueBuffers
 975 //*****************************************************************************
 976 //
 977 ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers(ALuint sourceName, ALsizei n, ALuint* buffers)
 978 {
 979     AL_VOID_FXN(alSourceUnqueueBuffers(sourceName, n, buffers));
 980 }
 981