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