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