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