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