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