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