OpenAL32/alState.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2000 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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "version.h"
  24
  25 #include <stdlib.h>
  26 #include "alMain.h"
  27 #include "AL/alc.h"
  28 #include "AL/al.h"
  29 #include "AL/alext.h"
  30 #include "alError.h"
  31 #include "alListener.h"
  32 #include "alSource.h"
  33 #include "alAuxEffectSlot.h"
  34
  35 #include "backends/base.h"
  36
  37
  38 static const ALchar alVendor[] = "OpenAL Community";
  39 static const ALchar alVersion[] = "1.1 ALSOFT "ALSOFT_VERSION;
  40 static const ALchar alRenderer[] = "OpenAL Soft";
  41
  42 // Error Messages
  43 static const ALchar alNoError[] = "No Error";
  44 static const ALchar alErrInvalidName[] = "Invalid Name";
  45 static const ALchar alErrInvalidEnum[] = "Invalid Enum";
  46 static const ALchar alErrInvalidValue[] = "Invalid Value";
  47 static const ALchar alErrInvalidOp[] = "Invalid Operation";
  48 static const ALchar alErrOutOfMemory[] = "Out of Memory";
  49
  50 /* Resampler strings */
  51 static const ALchar alPointResampler[] = "Nearest";
  52 static const ALchar alLinearResampler[] = "Linear";
  53 static const ALchar alSinc4Resampler[] = "4-Point Sinc";
  54 static const ALchar alBSincResampler[] = "Band-limited Sinc (12/24)";
  55
  56 AL_API ALvoid AL_APIENTRY alEnable(ALenum capability)
  57 {
  58     ALCcontext *context;
  59
  60     context = GetContextRef();
  61     if(!context) return;
  62
  63     WriteLock(&context->PropLock);
  64     switch(capability)
  65     {
  66     case AL_SOURCE_DISTANCE_MODEL:
  67         context->SourceDistanceModel = AL_TRUE;
  68         break;
  69
  70     default:
  71         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
  72     }
  73     if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
  74         UpdateListenerProps(context);
  75
  76 done:
  77     WriteUnlock(&context->PropLock);
  78     ALCcontext_DecRef(context);
  79 }
  80
  81 AL_API ALvoid AL_APIENTRY alDisable(ALenum capability)
  82 {
  83     ALCcontext *context;
  84
  85     context = GetContextRef();
  86     if(!context) return;
  87
  88     WriteLock(&context->PropLock);
  89     switch(capability)
  90     {
  91     case AL_SOURCE_DISTANCE_MODEL:
  92         context->SourceDistanceModel = AL_FALSE;
  93         break;
  94
  95     default:
  96         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
  97     }
  98     if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
  99         UpdateListenerProps(context);
 100
 101 done:
 102     WriteUnlock(&context->PropLock);
 103     ALCcontext_DecRef(context);
 104 }
 105
 106 AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability)
 107 {
 108     ALCcontext *context;
 109     ALboolean value=AL_FALSE;
 110
 111     context = GetContextRef();
 112     if(!context) return AL_FALSE;
 113
 114     switch(capability)
 115     {
 116     case AL_SOURCE_DISTANCE_MODEL:
 117         value = context->SourceDistanceModel;
 118         break;
 119
 120     default:
 121         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 122     }
 123
 124 done:
 125     ALCcontext_DecRef(context);
 126
 127     return value;
 128 }
 129
 130 AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum pname)
 131 {
 132     ALCcontext *context;
 133     ALboolean value=AL_FALSE;
 134
 135     context = GetContextRef();
 136     if(!context) return AL_FALSE;
 137
 138     switch(pname)
 139     {
 140     case AL_DOPPLER_FACTOR:
 141         if(context->DopplerFactor != 0.0f)
 142             value = AL_TRUE;
 143         break;
 144
 145     case AL_DOPPLER_VELOCITY:
 146         if(context->DopplerVelocity != 0.0f)
 147             value = AL_TRUE;
 148         break;
 149
 150     case AL_DISTANCE_MODEL:
 151         if(context->DistanceModel == AL_INVERSE_DISTANCE_CLAMPED)
 152             value = AL_TRUE;
 153         break;
 154
 155     case AL_SPEED_OF_SOUND:
 156         if(context->SpeedOfSound != 0.0f)
 157             value = AL_TRUE;
 158         break;
 159
 160     case AL_DEFERRED_UPDATES_SOFT:
 161         if(ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 162             value = AL_TRUE;
 163         break;
 164
 165     case AL_GAIN_LIMIT_SOFT:
 166         if(GAIN_MIX_MAX/context->GainBoost != 0.0f)
 167             value = AL_TRUE;
 168         break;
 169
 170     case AL_NUM_RESAMPLERS_SOFT:
 171         /* Always non-0. */
 172         value = AL_TRUE;
 173         break;
 174
 175     case AL_DEFAULT_RESAMPLER_SOFT:
 176         value = ResamplerDefault ? AL_TRUE : AL_FALSE;
 177         break;
 178
 179     default:
 180         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 181     }
 182
 183 done:
 184     ALCcontext_DecRef(context);
 185
 186     return value;
 187 }
 188
 189 AL_API ALdouble AL_APIENTRY alGetDouble(ALenum pname)
 190 {
 191     ALCcontext *context;
 192     ALdouble value = 0.0;
 193
 194     context = GetContextRef();
 195     if(!context) return 0.0;
 196
 197     switch(pname)
 198     {
 199     case AL_DOPPLER_FACTOR:
 200         value = (ALdouble)context->DopplerFactor;
 201         break;
 202
 203     case AL_DOPPLER_VELOCITY:
 204         value = (ALdouble)context->DopplerVelocity;
 205         break;
 206
 207     case AL_DISTANCE_MODEL:
 208         value = (ALdouble)context->DistanceModel;
 209         break;
 210
 211     case AL_SPEED_OF_SOUND:
 212         value = (ALdouble)context->SpeedOfSound;
 213         break;
 214
 215     case AL_DEFERRED_UPDATES_SOFT:
 216         if(ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 217             value = (ALdouble)AL_TRUE;
 218         break;
 219
 220     case AL_GAIN_LIMIT_SOFT:
 221         value = (ALdouble)GAIN_MIX_MAX/context->GainBoost;
 222         break;
 223
 224     case AL_NUM_RESAMPLERS_SOFT:
 225         value = (ALdouble)(ResamplerMax + 1);
 226         break;
 227
 228     case AL_DEFAULT_RESAMPLER_SOFT:
 229         value = (ALdouble)ResamplerDefault;
 230         break;
 231
 232     default:
 233         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 234     }
 235
 236 done:
 237     ALCcontext_DecRef(context);
 238
 239     return value;
 240 }
 241
 242 AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname)
 243 {
 244     ALCcontext *context;
 245     ALfloat value = 0.0f;
 246
 247     context = GetContextRef();
 248     if(!context) return 0.0f;
 249
 250     switch(pname)
 251     {
 252     case AL_DOPPLER_FACTOR:
 253         value = context->DopplerFactor;
 254         break;
 255
 256     case AL_DOPPLER_VELOCITY:
 257         value = context->DopplerVelocity;
 258         break;
 259
 260     case AL_DISTANCE_MODEL:
 261         value = (ALfloat)context->DistanceModel;
 262         break;
 263
 264     case AL_SPEED_OF_SOUND:
 265         value = context->SpeedOfSound;
 266         break;
 267
 268     case AL_DEFERRED_UPDATES_SOFT:
 269         if(ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 270             value = (ALfloat)AL_TRUE;
 271         break;
 272
 273     case AL_GAIN_LIMIT_SOFT:
 274         value = GAIN_MIX_MAX/context->GainBoost;
 275         break;
 276
 277     case AL_NUM_RESAMPLERS_SOFT:
 278         value = (ALfloat)(ResamplerMax + 1);
 279         break;
 280
 281     case AL_DEFAULT_RESAMPLER_SOFT:
 282         value = (ALfloat)ResamplerDefault;
 283         break;
 284
 285     default:
 286         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 287     }
 288
 289 done:
 290     ALCcontext_DecRef(context);
 291
 292     return value;
 293 }
 294
 295 AL_API ALint AL_APIENTRY alGetInteger(ALenum pname)
 296 {
 297     ALCcontext *context;
 298     ALint value = 0;
 299
 300     context = GetContextRef();
 301     if(!context) return 0;
 302
 303     switch(pname)
 304     {
 305     case AL_DOPPLER_FACTOR:
 306         value = (ALint)context->DopplerFactor;
 307         break;
 308
 309     case AL_DOPPLER_VELOCITY:
 310         value = (ALint)context->DopplerVelocity;
 311         break;
 312
 313     case AL_DISTANCE_MODEL:
 314         value = (ALint)context->DistanceModel;
 315         break;
 316
 317     case AL_SPEED_OF_SOUND:
 318         value = (ALint)context->SpeedOfSound;
 319         break;
 320
 321     case AL_DEFERRED_UPDATES_SOFT:
 322         if(ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 323             value = (ALint)AL_TRUE;
 324         break;
 325
 326     case AL_GAIN_LIMIT_SOFT:
 327         value = (ALint)(GAIN_MIX_MAX/context->GainBoost);
 328         break;
 329
 330     case AL_NUM_RESAMPLERS_SOFT:
 331         value = ResamplerMax + 1;
 332         break;
 333
 334     case AL_DEFAULT_RESAMPLER_SOFT:
 335         value = ResamplerDefault;
 336         break;
 337
 338     default:
 339         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 340     }
 341
 342 done:
 343     ALCcontext_DecRef(context);
 344
 345     return value;
 346 }
 347
 348 AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname)
 349 {
 350     ALCcontext *context;
 351     ALint64SOFT value = 0;
 352
 353     context = GetContextRef();
 354     if(!context) return 0;
 355
 356     switch(pname)
 357     {
 358     case AL_DOPPLER_FACTOR:
 359         value = (ALint64SOFT)context->DopplerFactor;
 360         break;
 361
 362     case AL_DOPPLER_VELOCITY:
 363         value = (ALint64SOFT)context->DopplerVelocity;
 364         break;
 365
 366     case AL_DISTANCE_MODEL:
 367         value = (ALint64SOFT)context->DistanceModel;
 368         break;
 369
 370     case AL_SPEED_OF_SOUND:
 371         value = (ALint64SOFT)context->SpeedOfSound;
 372         break;
 373
 374     case AL_DEFERRED_UPDATES_SOFT:
 375         if(ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 376             value = (ALint64SOFT)AL_TRUE;
 377         break;
 378
 379     case AL_GAIN_LIMIT_SOFT:
 380         value = (ALint64SOFT)(GAIN_MIX_MAX/context->GainBoost);
 381         break;
 382
 383     case AL_NUM_RESAMPLERS_SOFT:
 384         value = (ALint64SOFT)(ResamplerMax + 1);
 385         break;
 386
 387     case AL_DEFAULT_RESAMPLER_SOFT:
 388         value = (ALint64SOFT)ResamplerDefault;
 389         break;
 390
 391     default:
 392         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 393     }
 394
 395 done:
 396     ALCcontext_DecRef(context);
 397
 398     return value;
 399 }
 400
 401 AL_API ALvoid AL_APIENTRY alGetBooleanv(ALenum pname, ALboolean *values)
 402 {
 403     ALCcontext *context;
 404
 405     if(values)
 406     {
 407         switch(pname)
 408         {
 409             case AL_DOPPLER_FACTOR:
 410             case AL_DOPPLER_VELOCITY:
 411             case AL_DISTANCE_MODEL:
 412             case AL_SPEED_OF_SOUND:
 413             case AL_DEFERRED_UPDATES_SOFT:
 414             case AL_GAIN_LIMIT_SOFT:
 415             case AL_NUM_RESAMPLERS_SOFT:
 416             case AL_DEFAULT_RESAMPLER_SOFT:
 417                 values[0] = alGetBoolean(pname);
 418                 return;
 419         }
 420     }
 421
 422     context = GetContextRef();
 423     if(!context) return;
 424
 425     if(!(values))
 426         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 427     switch(pname)
 428     {
 429     default:
 430         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 431     }
 432
 433 done:
 434     ALCcontext_DecRef(context);
 435 }
 436
 437 AL_API ALvoid AL_APIENTRY alGetDoublev(ALenum pname, ALdouble *values)
 438 {
 439     ALCcontext *context;
 440
 441     if(values)
 442     {
 443         switch(pname)
 444         {
 445             case AL_DOPPLER_FACTOR:
 446             case AL_DOPPLER_VELOCITY:
 447             case AL_DISTANCE_MODEL:
 448             case AL_SPEED_OF_SOUND:
 449             case AL_DEFERRED_UPDATES_SOFT:
 450             case AL_GAIN_LIMIT_SOFT:
 451             case AL_NUM_RESAMPLERS_SOFT:
 452             case AL_DEFAULT_RESAMPLER_SOFT:
 453                 values[0] = alGetDouble(pname);
 454                 return;
 455         }
 456     }
 457
 458     context = GetContextRef();
 459     if(!context) return;
 460
 461     if(!(values))
 462         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 463     switch(pname)
 464     {
 465     default:
 466         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 467     }
 468
 469 done:
 470     ALCcontext_DecRef(context);
 471 }
 472
 473 AL_API ALvoid AL_APIENTRY alGetFloatv(ALenum pname, ALfloat *values)
 474 {
 475     ALCcontext *context;
 476
 477     if(values)
 478     {
 479         switch(pname)
 480         {
 481             case AL_DOPPLER_FACTOR:
 482             case AL_DOPPLER_VELOCITY:
 483             case AL_DISTANCE_MODEL:
 484             case AL_SPEED_OF_SOUND:
 485             case AL_DEFERRED_UPDATES_SOFT:
 486             case AL_GAIN_LIMIT_SOFT:
 487             case AL_NUM_RESAMPLERS_SOFT:
 488             case AL_DEFAULT_RESAMPLER_SOFT:
 489                 values[0] = alGetFloat(pname);
 490                 return;
 491         }
 492     }
 493
 494     context = GetContextRef();
 495     if(!context) return;
 496
 497     if(!(values))
 498         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 499     switch(pname)
 500     {
 501     default:
 502         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 503     }
 504
 505 done:
 506     ALCcontext_DecRef(context);
 507 }
 508
 509 AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname, ALint *values)
 510 {
 511     ALCcontext *context;
 512
 513     if(values)
 514     {
 515         switch(pname)
 516         {
 517             case AL_DOPPLER_FACTOR:
 518             case AL_DOPPLER_VELOCITY:
 519             case AL_DISTANCE_MODEL:
 520             case AL_SPEED_OF_SOUND:
 521             case AL_DEFERRED_UPDATES_SOFT:
 522             case AL_GAIN_LIMIT_SOFT:
 523             case AL_NUM_RESAMPLERS_SOFT:
 524             case AL_DEFAULT_RESAMPLER_SOFT:
 525                 values[0] = alGetInteger(pname);
 526                 return;
 527         }
 528     }
 529
 530     context = GetContextRef();
 531     if(!context) return;
 532
 533     switch(pname)
 534     {
 535     default:
 536         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 537     }
 538
 539 done:
 540     ALCcontext_DecRef(context);
 541 }
 542
 543 AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values)
 544 {
 545     ALCcontext *context;
 546
 547     if(values)
 548     {
 549         switch(pname)
 550         {
 551             case AL_DOPPLER_FACTOR:
 552             case AL_DOPPLER_VELOCITY:
 553             case AL_DISTANCE_MODEL:
 554             case AL_SPEED_OF_SOUND:
 555             case AL_DEFERRED_UPDATES_SOFT:
 556             case AL_GAIN_LIMIT_SOFT:
 557             case AL_NUM_RESAMPLERS_SOFT:
 558             case AL_DEFAULT_RESAMPLER_SOFT:
 559                 values[0] = alGetInteger64SOFT(pname);
 560                 return;
 561         }
 562     }
 563
 564     context = GetContextRef();
 565     if(!context) return;
 566
 567     switch(pname)
 568     {
 569     default:
 570         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 571     }
 572
 573 done:
 574     ALCcontext_DecRef(context);
 575 }
 576
 577 AL_API const ALchar* AL_APIENTRY alGetString(ALenum pname)
 578 {
 579     const ALchar *value = NULL;
 580     ALCcontext *context;
 581
 582     context = GetContextRef();
 583     if(!context) return NULL;
 584
 585     switch(pname)
 586     {
 587     case AL_VENDOR:
 588         value = alVendor;
 589         break;
 590
 591     case AL_VERSION:
 592         value = alVersion;
 593         break;
 594
 595     case AL_RENDERER:
 596         value = alRenderer;
 597         break;
 598
 599     case AL_EXTENSIONS:
 600         value = context->ExtensionList;
 601         break;
 602
 603     case AL_NO_ERROR:
 604         value = alNoError;
 605         break;
 606
 607     case AL_INVALID_NAME:
 608         value = alErrInvalidName;
 609         break;
 610
 611     case AL_INVALID_ENUM:
 612         value = alErrInvalidEnum;
 613         break;
 614
 615     case AL_INVALID_VALUE:
 616         value = alErrInvalidValue;
 617         break;
 618
 619     case AL_INVALID_OPERATION:
 620         value = alErrInvalidOp;
 621         break;
 622
 623     case AL_OUT_OF_MEMORY:
 624         value = alErrOutOfMemory;
 625         break;
 626
 627     default:
 628         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 629     }
 630
 631 done:
 632     ALCcontext_DecRef(context);
 633
 634     return value;
 635 }
 636
 637 AL_API ALvoid AL_APIENTRY alDopplerFactor(ALfloat value)
 638 {
 639     ALCcontext *context;
 640
 641     context = GetContextRef();
 642     if(!context) return;
 643
 644     if(!(value >= 0.0f && isfinite(value)))
 645         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 646
 647     WriteLock(&context->PropLock);
 648     context->DopplerFactor = value;
 649     if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 650         UpdateListenerProps(context);
 651     WriteUnlock(&context->PropLock);
 652
 653 done:
 654     ALCcontext_DecRef(context);
 655 }
 656
 657 AL_API ALvoid AL_APIENTRY alDopplerVelocity(ALfloat value)
 658 {
 659     ALCcontext *context;
 660
 661     context = GetContextRef();
 662     if(!context) return;
 663
 664     if(!(value >= 0.0f && isfinite(value)))
 665         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 666
 667     WriteLock(&context->PropLock);
 668     context->DopplerVelocity = value;
 669     if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 670         UpdateListenerProps(context);
 671     WriteUnlock(&context->PropLock);
 672
 673 done:
 674     ALCcontext_DecRef(context);
 675 }
 676
 677 AL_API ALvoid AL_APIENTRY alSpeedOfSound(ALfloat value)
 678 {
 679     ALCcontext *context;
 680
 681     context = GetContextRef();
 682     if(!context) return;
 683
 684     if(!(value > 0.0f && isfinite(value)))
 685         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 686
 687     WriteLock(&context->PropLock);
 688     context->SpeedOfSound = value;
 689     if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 690         UpdateListenerProps(context);
 691     WriteUnlock(&context->PropLock);
 692
 693 done:
 694     ALCcontext_DecRef(context);
 695 }
 696
 697 AL_API ALvoid AL_APIENTRY alDistanceModel(ALenum value)
 698 {
 699     ALCcontext *context;
 700
 701     context = GetContextRef();
 702     if(!context) return;
 703
 704     if(!(value == AL_INVERSE_DISTANCE || value == AL_INVERSE_DISTANCE_CLAMPED ||
 705          value == AL_LINEAR_DISTANCE || value == AL_LINEAR_DISTANCE_CLAMPED ||
 706          value == AL_EXPONENT_DISTANCE || value == AL_EXPONENT_DISTANCE_CLAMPED ||
 707          value == AL_NONE))
 708         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 709
 710     WriteLock(&context->PropLock);
 711     context->DistanceModel = value;
 712     if(!context->SourceDistanceModel)
 713     {
 714         if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))
 715             UpdateListenerProps(context);
 716     }
 717     WriteUnlock(&context->PropLock);
 718
 719 done:
 720     ALCcontext_DecRef(context);
 721 }
 722
 723
 724 AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void)
 725 {
 726     ALCcontext *context;
 727
 728     context = GetContextRef();
 729     if(!context) return;
 730
 731     ALCcontext_DeferUpdates(context);
 732
 733     ALCcontext_DecRef(context);
 734 }
 735
 736 AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void)
 737 {
 738     ALCcontext *context;
 739
 740     context = GetContextRef();
 741     if(!context) return;
 742
 743     ALCcontext_ProcessUpdates(context);
 744
 745     ALCcontext_DecRef(context);
 746 }
 747
 748
 749 AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index)
 750 {
 751     const char *ResamplerNames[] = {
 752         alPointResampler, alLinearResampler,
 753         alSinc4Resampler, alBSincResampler,
 754     };
 755     const ALchar *value = NULL;
 756     ALCcontext *context;
 757
 758     static_assert(COUNTOF(ResamplerNames) == ResamplerMax+1, "Incorrect ResamplerNames list");
 759
 760     context = GetContextRef();
 761     if(!context) return NULL;
 762
 763     switch(pname)
 764     {
 765     case AL_RESAMPLER_NAME_SOFT:
 766         if(index < 0 || (size_t)index >= COUNTOF(ResamplerNames))
 767             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 768         value = ResamplerNames[index];
 769         break;
 770
 771     default:
 772         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 773     }
 774
 775 done:
 776     ALCcontext_DecRef(context);
 777
 778     return value;
 779 }