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