OpenAL32/alState.cpp

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