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