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