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