OpenAL32/alEffect.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 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
  25 #include "AL/al.h"
  26 #include "AL/alc.h"
  27 #include "alMain.h"
  28 #include "alEffect.h"
  29 #include "alThunk.h"
  30 #include "alError.h"
  31
  32 static ALeffect *g_EffectList;
  33 static ALuint    g_EffectCount;
  34
  35 static void InitEffectParams(ALeffect *effect, ALenum type);
  36
  37
  38 ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
  39 {
  40     ALCcontext *Context;
  41     ALsizei i;
  42
  43     Context = alcGetCurrentContext();
  44     SuspendContext(Context);
  45
  46     if (n > 0)
  47     {
  48         // Check that enough memory has been allocted in the 'effects' array for n Effects
  49         if (!IsBadWritePtr((void*)effects, n * sizeof(ALuint)))
  50         {
  51             ALeffect **list = &g_EffectList;
  52             while(*list)
  53                 list = &(*list)->next;
  54
  55             i = 0;
  56             while(i < n)
  57             {
  58                 *list = calloc(1, sizeof(ALeffect));
  59                 if(!(*list))
  60                 {
  61                     // We must have run out or memory
  62                     alDeleteEffects(i, effects);
  63                     alSetError(AL_OUT_OF_MEMORY);
  64                     break;
  65                 }
  66
  67                 effects[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  68                 (*list)->effect = effects[i];
  69
  70                 InitEffectParams(*list, AL_EFFECT_NULL);
  71                 g_EffectCount++;
  72                 i++;
  73
  74                 list = &(*list)->next;
  75             }
  76         }
  77     }
  78
  79     ProcessContext(Context);
  80 }
  81
  82 ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
  83 {
  84     ALCcontext *Context;
  85     ALeffect *ALEffect;
  86     ALsizei i;
  87
  88     Context = alcGetCurrentContext();
  89     SuspendContext(Context);
  90
  91     if (n >= 0)
  92     {
  93         // Check that all effects are valid
  94         for (i = 0; i < n; i++)
  95         {
  96             if (!alIsEffect(effects[i]))
  97             {
  98                 alSetError(AL_INVALID_NAME);
  99                 break;
 100             }
 101         }
 102
 103         if (i == n)
 104         {
 105             // All effects are valid
 106             for (i = 0; i < n; i++)
 107             {
 108                 // Recheck that the effect is valid, because there could be duplicated names
 109                 if (effects[i] && alIsEffect(effects[i]))
 110                 {
 111                     ALeffect **list;
 112
 113                     ALEffect = ((ALeffect*)ALTHUNK_LOOKUPENTRY(effects[i]));
 114
 115                     // Remove Source from list of Sources
 116                     list = &g_EffectList;
 117                     while(*list && *list != ALEffect)
 118                          list = &(*list)->next;
 119
 120                     if(*list)
 121                         *list = (*list)->next;
 122                     ALTHUNK_REMOVEENTRY(ALEffect->effect);
 123
 124                     memset(ALEffect, 0, sizeof(ALeffect));
 125                     free(ALEffect);
 126
 127                     g_EffectCount--;
 128                 }
 129             }
 130         }
 131     }
 132     else
 133         alSetError(AL_INVALID_VALUE);
 134
 135     ProcessContext(Context);
 136 }
 137
 138 ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 139 {
 140     ALCcontext *Context;
 141     ALeffect **list;
 142
 143     Context = alcGetCurrentContext();
 144     SuspendContext(Context);
 145
 146     list = &g_EffectList;
 147     while(*list && (*list)->effect != effect)
 148         list = &(*list)->next;
 149
 150     ProcessContext(Context);
 151
 152     return ((*list || !effect) ? AL_TRUE : AL_FALSE);
 153 }
 154
 155 ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 156 {
 157     ALCcontext *Context;
 158
 159     Context = alcGetCurrentContext();
 160     SuspendContext(Context);
 161
 162     if (effect && alIsEffect(effect))
 163     {
 164         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 165
 166         if(param == AL_EFFECT_TYPE)
 167         {
 168             if(iValue == AL_EFFECT_NULL ||
 169                iValue == AL_EFFECT_REVERB)
 170                 InitEffectParams(ALEffect, iValue);
 171             else
 172                 alSetError(AL_INVALID_VALUE);
 173         }
 174         else if(ALEffect->type == AL_EFFECT_REVERB)
 175         {
 176             switch(param)
 177             {
 178             case AL_REVERB_DECAY_HFLIMIT:
 179                 if(iValue == AL_TRUE || iValue == AL_FALSE)
 180                     ALEffect->Reverb.DecayHFLimit = iValue;
 181                 else
 182                     alSetError(AL_INVALID_VALUE);
 183                 break;
 184
 185             default:
 186                 alSetError(AL_INVALID_ENUM);
 187                 break;
 188             }
 189         }
 190         else
 191             alSetError(AL_INVALID_ENUM);
 192     }
 193     else
 194         alSetError(AL_INVALID_NAME);
 195
 196     ProcessContext(Context);
 197 }
 198
 199 ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues)
 200 {
 201     ALCcontext *Context;
 202
 203     Context = alcGetCurrentContext();
 204     SuspendContext(Context);
 205
 206     if (effect && alIsEffect(effect))
 207     {
 208         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 209
 210         if(param == AL_EFFECT_TYPE)
 211         {
 212             alEffecti(effect, param, piValues[0]);
 213         }
 214         else if(ALEffect->type == AL_EFFECT_REVERB)
 215         {
 216             switch(param)
 217             {
 218             case AL_REVERB_DECAY_HFLIMIT:
 219                 alEffecti(effect, param, piValues[0]);
 220                 break;
 221
 222             default:
 223                 alSetError(AL_INVALID_ENUM);
 224                 break;
 225             }
 226         }
 227         else
 228             alSetError(AL_INVALID_ENUM);
 229     }
 230     else
 231         alSetError(AL_INVALID_NAME);
 232
 233     ProcessContext(Context);
 234 }
 235
 236 ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
 237 {
 238     ALCcontext *Context;
 239
 240     Context = alcGetCurrentContext();
 241     SuspendContext(Context);
 242
 243     if (effect && alIsEffect(effect))
 244     {
 245         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 246
 247         if(ALEffect->type == AL_EFFECT_REVERB)
 248         {
 249             switch(param)
 250             {
 251             case AL_REVERB_DENSITY:
 252                 if(flValue >= 0.0f && flValue <= 1.0f)
 253                     ALEffect->Reverb.Density = flValue;
 254                 else
 255                     alSetError(AL_INVALID_VALUE);
 256                 break;
 257
 258             case AL_REVERB_DIFFUSION:
 259                 if(flValue >= 0.0f && flValue <= 1.0f)
 260                     ALEffect->Reverb.Diffusion = flValue;
 261                 else
 262                     alSetError(AL_INVALID_VALUE);
 263                 break;
 264
 265             case AL_REVERB_GAIN:
 266                 if(flValue >= 0.0f && flValue <= 1.0f)
 267                     ALEffect->Reverb.Gain = flValue;
 268                 else
 269                     alSetError(AL_INVALID_VALUE);
 270                 break;
 271
 272             case AL_REVERB_GAINHF:
 273                 if(flValue >= 0.0f && flValue <= 1.0f)
 274                     ALEffect->Reverb.GainHF = flValue;
 275                 else
 276                     alSetError(AL_INVALID_VALUE);
 277                 break;
 278
 279             case AL_REVERB_DECAY_TIME:
 280                 if(flValue >= 0.1f && flValue <= 20.0f)
 281                     ALEffect->Reverb.DecayTime = flValue;
 282                 else
 283                     alSetError(AL_INVALID_VALUE);
 284                 break;
 285
 286             case AL_REVERB_DECAY_HFRATIO:
 287                 if(flValue >= 0.1f && flValue <= 2.0f)
 288                     ALEffect->Reverb.DecayHFRatio = flValue;
 289                 else
 290                     alSetError(AL_INVALID_VALUE);
 291                 break;
 292
 293             case AL_REVERB_REFLECTIONS_GAIN:
 294                 if(flValue >= 0.0f && flValue <= 3.16f)
 295                     ALEffect->Reverb.ReflectionsGain = flValue;
 296                 else
 297                     alSetError(AL_INVALID_VALUE);
 298                 break;
 299
 300             case AL_REVERB_REFLECTIONS_DELAY:
 301                 if(flValue >= 0.0f && flValue <= 0.3f)
 302                     ALEffect->Reverb.ReflectionsDelay = flValue;
 303                 else
 304                     alSetError(AL_INVALID_VALUE);
 305                 break;
 306
 307             case AL_REVERB_LATE_REVERB_GAIN:
 308                 if(flValue >= 0.0f && flValue <= 10.0f)
 309                     ALEffect->Reverb.LateReverbGain = flValue;
 310                 else
 311                     alSetError(AL_INVALID_VALUE);
 312                 break;
 313
 314             case AL_REVERB_LATE_REVERB_DELAY:
 315                 if(flValue >= 0.0f && flValue <= 0.1f)
 316                     ALEffect->Reverb.LateReverbDelay = flValue;
 317                 else
 318                     alSetError(AL_INVALID_VALUE);
 319                 break;
 320
 321             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 322                 if(flValue >= 0.892f && flValue <= 1.0f)
 323                     ALEffect->Reverb.AirAbsorptionGainHF = flValue;
 324                 else
 325                     alSetError(AL_INVALID_VALUE);
 326                 break;
 327
 328             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 329                 if(flValue >= 0.0f && flValue <= 10.0f)
 330                     ALEffect->Reverb.RoomRolloffFactor = flValue;
 331                 else
 332                     alSetError(AL_INVALID_VALUE);
 333                 break;
 334
 335             default:
 336                 alSetError(AL_INVALID_ENUM);
 337                 break;
 338             }
 339         }
 340         else
 341             alSetError(AL_INVALID_ENUM);
 342     }
 343     else
 344         alSetError(AL_INVALID_NAME);
 345
 346     ProcessContext(Context);
 347 }
 348
 349 ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 350 {
 351     ALCcontext *Context;
 352
 353     Context = alcGetCurrentContext();
 354     SuspendContext(Context);
 355
 356     if (effect && alIsEffect(effect))
 357     {
 358         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 359
 360         if(ALEffect->type == AL_EFFECT_REVERB)
 361         {
 362             switch(param)
 363             {
 364             case AL_REVERB_DENSITY:
 365             case AL_REVERB_DIFFUSION:
 366             case AL_REVERB_GAIN:
 367             case AL_REVERB_GAINHF:
 368             case AL_REVERB_DECAY_TIME:
 369             case AL_REVERB_DECAY_HFRATIO:
 370             case AL_REVERB_REFLECTIONS_GAIN:
 371             case AL_REVERB_REFLECTIONS_DELAY:
 372             case AL_REVERB_LATE_REVERB_GAIN:
 373             case AL_REVERB_LATE_REVERB_DELAY:
 374             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 375             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 376                 alEffectf(effect, param, pflValues[0]);
 377                 break;
 378
 379             default:
 380                 alSetError(AL_INVALID_ENUM);
 381                 break;
 382             }
 383         }
 384         else
 385             alSetError(AL_INVALID_ENUM);
 386     }
 387     else
 388         alSetError(AL_INVALID_NAME);
 389
 390     ProcessContext(Context);
 391 }
 392
 393 ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
 394 {
 395     ALCcontext *Context;
 396
 397     Context = alcGetCurrentContext();
 398     SuspendContext(Context);
 399
 400     if (effect && alIsEffect(effect))
 401     {
 402         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 403
 404         if(param == AL_EFFECT_TYPE)
 405         {
 406             *piValue = ALEffect->type;
 407         }
 408         else if(ALEffect->type == AL_EFFECT_REVERB)
 409         {
 410             switch(param)
 411             {
 412             case AL_REVERB_DECAY_HFLIMIT:
 413                 *piValue = ALEffect->Reverb.DecayHFLimit;
 414                 break;
 415
 416             default:
 417                 alSetError(AL_INVALID_ENUM);
 418                 break;
 419             }
 420         }
 421         else
 422             alSetError(AL_INVALID_ENUM);
 423     }
 424     else
 425         alSetError(AL_INVALID_NAME);
 426
 427     ProcessContext(Context);
 428 }
 429
 430 ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
 431 {
 432     ALCcontext *Context;
 433
 434     Context = alcGetCurrentContext();
 435     SuspendContext(Context);
 436
 437     if (effect && alIsEffect(effect))
 438     {
 439         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 440
 441         if(param == AL_EFFECT_TYPE)
 442         {
 443             alGetEffecti(effect, param, piValues);
 444         }
 445         else if(ALEffect->type == AL_EFFECT_REVERB)
 446         {
 447             switch(param)
 448             {
 449             case AL_REVERB_DECAY_HFLIMIT:
 450                 alGetEffecti(effect, param, piValues);
 451                 break;
 452
 453             default:
 454                 alSetError(AL_INVALID_ENUM);
 455                 break;
 456             }
 457         }
 458         else
 459             alSetError(AL_INVALID_ENUM);
 460     }
 461     else
 462         alSetError(AL_INVALID_NAME);
 463
 464     ProcessContext(Context);
 465 }
 466
 467 ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
 468 {
 469     ALCcontext *Context;
 470
 471     Context = alcGetCurrentContext();
 472     SuspendContext(Context);
 473
 474     if (effect && alIsEffect(effect))
 475     {
 476         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 477
 478         if(ALEffect->type == AL_EFFECT_REVERB)
 479         {
 480             switch(param)
 481             {
 482             case AL_REVERB_DENSITY:
 483                 *pflValue = ALEffect->Reverb.Density;
 484                 break;
 485
 486             case AL_REVERB_DIFFUSION:
 487                 *pflValue = ALEffect->Reverb.Diffusion;
 488                 break;
 489
 490             case AL_REVERB_GAIN:
 491                 *pflValue = ALEffect->Reverb.Gain;
 492                 break;
 493
 494             case AL_REVERB_GAINHF:
 495                 *pflValue = ALEffect->Reverb.GainHF;
 496                 break;
 497
 498             case AL_REVERB_DECAY_TIME:
 499                 *pflValue = ALEffect->Reverb.DecayTime;
 500                 break;
 501
 502             case AL_REVERB_DECAY_HFRATIO:
 503                 *pflValue = ALEffect->Reverb.DecayHFRatio;
 504                 break;
 505
 506             case AL_REVERB_REFLECTIONS_GAIN:
 507                 *pflValue = ALEffect->Reverb.ReflectionsGain;
 508                 break;
 509
 510             case AL_REVERB_REFLECTIONS_DELAY:
 511                 *pflValue = ALEffect->Reverb.ReflectionsDelay;
 512                 break;
 513
 514             case AL_REVERB_LATE_REVERB_GAIN:
 515                 *pflValue = ALEffect->Reverb.LateReverbGain;
 516                 break;
 517
 518             case AL_REVERB_LATE_REVERB_DELAY:
 519                 *pflValue = ALEffect->Reverb.LateReverbDelay;
 520                 break;
 521
 522             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 523                 *pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
 524                 break;
 525
 526             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 527                 *pflValue = ALEffect->Reverb.RoomRolloffFactor;
 528                 break;
 529
 530             default:
 531                 alSetError(AL_INVALID_ENUM);
 532                 break;
 533             }
 534         }
 535         else
 536             alSetError(AL_INVALID_ENUM);
 537     }
 538     else
 539         alSetError(AL_INVALID_NAME);
 540
 541     ProcessContext(Context);
 542 }
 543
 544 ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 545 {
 546     ALCcontext *Context;
 547
 548     Context = alcGetCurrentContext();
 549     SuspendContext(Context);
 550
 551     if (effect && alIsEffect(effect))
 552     {
 553         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 554
 555         if(ALEffect->type == AL_EFFECT_REVERB)
 556         {
 557             switch(param)
 558             {
 559             case AL_REVERB_DENSITY:
 560             case AL_REVERB_DIFFUSION:
 561             case AL_REVERB_GAIN:
 562             case AL_REVERB_GAINHF:
 563             case AL_REVERB_DECAY_TIME:
 564             case AL_REVERB_DECAY_HFRATIO:
 565             case AL_REVERB_REFLECTIONS_GAIN:
 566             case AL_REVERB_REFLECTIONS_DELAY:
 567             case AL_REVERB_LATE_REVERB_GAIN:
 568             case AL_REVERB_LATE_REVERB_DELAY:
 569             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 570             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 571                 alGetEffectf(effect, param, pflValues);
 572                 break;
 573
 574             default:
 575                 alSetError(AL_INVALID_ENUM);
 576                 break;
 577             }
 578         }
 579         else
 580             alSetError(AL_INVALID_ENUM);
 581     }
 582     else
 583         alSetError(AL_INVALID_NAME);
 584
 585     ProcessContext(Context);
 586 }
 587
 588
 589 ALvoid ReleaseALEffects(ALvoid)
 590 {
 591 #ifdef _DEBUG
 592     if(g_EffectCount > 0)
 593         AL_PRINT("exit(): deleting %d Effect(s)\n", g_EffectCount);
 594 #endif
 595
 596     while(g_EffectList)
 597     {
 598         ALeffect *temp = g_EffectList;
 599         g_EffectList = g_EffectList->next;
 600
 601         // Release effect structure
 602         memset(temp, 0, sizeof(ALeffect));
 603         free(temp);
 604     }
 605     g_EffectCount = 0;
 606 }
 607
 608
 609 static void InitEffectParams(ALeffect *effect, ALenum type)
 610 {
 611     effect->type = type;
 612     switch(type)
 613     {
 614     case AL_EFFECT_REVERB:
 615         effect->Reverb.Density = 1.0f;
 616         effect->Reverb.Diffusion = 1.0f;
 617         effect->Reverb.Gain = 0.32f;
 618         effect->Reverb.GainHF = 0.89f;
 619         effect->Reverb.DecayTime = 1.49f;
 620         effect->Reverb.DecayHFRatio = 0.83f;
 621         effect->Reverb.ReflectionsGain = 0.05f;
 622         effect->Reverb.ReflectionsDelay = 0.007f;
 623         effect->Reverb.LateReverbGain = 1.26f;
 624         effect->Reverb.LateReverbDelay = 0.011f;
 625         effect->Reverb.AirAbsorptionGainHF = 0.994f;
 626         effect->Reverb.RoomRolloffFactor = 0.0f;
 627         effect->Reverb.DecayHFLimit = AL_TRUE;
 628         break;
 629     }
 630 }