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 #include <math.h>
  25
  26 #include "AL/al.h"
  27 #include "AL/alc.h"
  28 #include "alMain.h"
  29 #include "alEffect.h"
  30 #include "alThunk.h"
  31 #include "alError.h"
  32
  33
  34 ALboolean DisabledEffects[MAX_EFFECTS];
  35
  36
  37 static void InitEffectParams(ALeffect *effect, ALenum type);
  38
  39 #define LookupEffect(m, k) ((ALeffect*)LookupUIntMapKey(&(m), (k)))
  40
  41 AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
  42 {
  43     ALCcontext *Context;
  44     ALsizei i=0;
  45
  46     Context = GetContextSuspended();
  47     if(!Context) return;
  48
  49     if(n < 0 || IsBadWritePtr((void*)effects, n * sizeof(ALuint)))
  50         alSetError(Context, AL_INVALID_VALUE);
  51     else
  52     {
  53         ALCdevice *device = Context->Device;
  54         ALenum err;
  55
  56         while(i < n)
  57         {
  58             ALeffect *effect = calloc(1, sizeof(ALeffect));
  59             if(!effect)
  60             {
  61                 alSetError(Context, AL_OUT_OF_MEMORY);
  62                 alDeleteEffects(i, effects);
  63                 break;
  64             }
  65
  66             effect->effect = ALTHUNK_ADDENTRY(effect);
  67             err = InsertUIntMapEntry(&device->EffectMap, effect->effect, effect);
  68             if(err != AL_NO_ERROR)
  69             {
  70                 ALTHUNK_REMOVEENTRY(effect->effect);
  71                 memset(effect, 0, sizeof(ALeffect));
  72                 free(effect);
  73
  74                 alSetError(Context, err);
  75                 alDeleteEffects(i, effects);
  76                 break;
  77             }
  78
  79             effects[i++] = effect->effect;
  80             InitEffectParams(effect, AL_EFFECT_NULL);
  81         }
  82     }
  83
  84     ProcessContext(Context);
  85 }
  86
  87 AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
  88 {
  89     ALCcontext *Context;
  90     ALCdevice *device;
  91     ALeffect *ALEffect;
  92     ALboolean Failed;
  93     ALsizei i;
  94
  95     Context = GetContextSuspended();
  96     if(!Context) return;
  97
  98     Failed = AL_TRUE;
  99     device = Context->Device;
 100     if(n < 0)
 101         alSetError(Context, AL_INVALID_VALUE);
 102     else
 103     {
 104         Failed = AL_FALSE;
 105         // Check that all effects are valid
 106         for(i = 0;i < n;i++)
 107         {
 108             if(!effects[i])
 109                 continue;
 110
 111             if(LookupEffect(device->EffectMap, effects[i]) == NULL)
 112             {
 113                 alSetError(Context, AL_INVALID_NAME);
 114                 Failed = AL_TRUE;
 115                 break;
 116             }
 117         }
 118     }
 119
 120     if(!Failed)
 121     {
 122         // All effects are valid
 123         for(i = 0;i < n;i++)
 124         {
 125             // Recheck that the effect is valid, because there could be duplicated names
 126             if((ALEffect=LookupEffect(device->EffectMap, effects[i])) == NULL)
 127                 continue;
 128
 129             RemoveUIntMapKey(&device->EffectMap, ALEffect->effect);
 130             ALTHUNK_REMOVEENTRY(ALEffect->effect);
 131
 132             memset(ALEffect, 0, sizeof(ALeffect));
 133             free(ALEffect);
 134         }
 135     }
 136
 137     ProcessContext(Context);
 138 }
 139
 140 AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 141 {
 142     ALCcontext *Context;
 143     ALboolean  result;
 144
 145     Context = GetContextSuspended();
 146     if(!Context) return AL_FALSE;
 147
 148     result = ((!effect || LookupEffect(Context->Device->EffectMap, effect)) ?
 149               AL_TRUE : AL_FALSE);
 150
 151     ProcessContext(Context);
 152
 153     return result;
 154 }
 155
 156 AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 157 {
 158     ALCcontext *Context;
 159     ALCdevice  *Device;
 160     ALeffect   *ALEffect;
 161
 162     Context = GetContextSuspended();
 163     if(!Context) return;
 164
 165     Device = Context->Device;
 166     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 167     {
 168         if(param == AL_EFFECT_TYPE)
 169         {
 170             ALboolean isOk = (iValue == AL_EFFECT_NULL ||
 171                 (iValue == AL_EFFECT_EAXREVERB && !DisabledEffects[EAXREVERB]) ||
 172                 (iValue == AL_EFFECT_REVERB && !DisabledEffects[REVERB]) ||
 173                 (iValue == AL_EFFECT_ECHO && !DisabledEffects[ECHO]) ||
 174                 (iValue == AL_EFFECT_RING_MODULATOR && !DisabledEffects[MODULATOR]));
 175
 176             if(isOk)
 177                 InitEffectParams(ALEffect, iValue);
 178             else
 179                 alSetError(Context, AL_INVALID_VALUE);
 180         }
 181         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 182         {
 183             switch(param)
 184             {
 185             case AL_EAXREVERB_DECAY_HFLIMIT:
 186                 if(iValue >= AL_EAXREVERB_MIN_DECAY_HFLIMIT &&
 187                    iValue <= AL_EAXREVERB_MAX_DECAY_HFLIMIT)
 188                     ALEffect->Reverb.DecayHFLimit = iValue;
 189                 else
 190                     alSetError(Context, AL_INVALID_VALUE);
 191                 break;
 192
 193             default:
 194                 alSetError(Context, AL_INVALID_ENUM);
 195                 break;
 196             }
 197         }
 198         else if(ALEffect->type == AL_EFFECT_REVERB)
 199         {
 200             switch(param)
 201             {
 202             case AL_REVERB_DECAY_HFLIMIT:
 203                 if(iValue >= AL_REVERB_MIN_DECAY_HFLIMIT &&
 204                    iValue <= AL_REVERB_MAX_DECAY_HFLIMIT)
 205                     ALEffect->Reverb.DecayHFLimit = iValue;
 206                 else
 207                     alSetError(Context, AL_INVALID_VALUE);
 208                 break;
 209
 210             default:
 211                 alSetError(Context, AL_INVALID_ENUM);
 212                 break;
 213             }
 214         }
 215         else if(ALEffect->type == AL_EFFECT_ECHO)
 216         {
 217             switch(param)
 218             {
 219             default:
 220                 alSetError(Context, AL_INVALID_ENUM);
 221                 break;
 222             }
 223         }
 224         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
 225         {
 226             switch(param)
 227             {
 228             case AL_RING_MODULATOR_FREQUENCY:
 229             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 230                 alEffectf(effect, param, (ALfloat)iValue);
 231                 break;
 232
 233             case AL_RING_MODULATOR_WAVEFORM:
 234                 if(iValue >= AL_RING_MODULATOR_MIN_WAVEFORM &&
 235                    iValue <= AL_RING_MODULATOR_MAX_WAVEFORM)
 236                     ALEffect->Modulator.Waveform = iValue;
 237                 else
 238                     alSetError(Context, AL_INVALID_VALUE);
 239                 break;
 240
 241             default:
 242                 alSetError(Context, AL_INVALID_ENUM);
 243                 break;
 244             }
 245         }
 246         else
 247             alSetError(Context, AL_INVALID_ENUM);
 248     }
 249     else
 250         alSetError(Context, AL_INVALID_NAME);
 251
 252     ProcessContext(Context);
 253 }
 254
 255 AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues)
 256 {
 257     ALCcontext *Context;
 258     ALCdevice  *Device;
 259     ALeffect   *ALEffect;
 260
 261     Context = GetContextSuspended();
 262     if(!Context) return;
 263
 264     Device = Context->Device;
 265     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 266     {
 267         if(param == AL_EFFECT_TYPE)
 268         {
 269             alEffecti(effect, param, piValues[0]);
 270         }
 271         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 272         {
 273             switch(param)
 274             {
 275             case AL_EAXREVERB_DECAY_HFLIMIT:
 276                 alEffecti(effect, param, piValues[0]);
 277                 break;
 278
 279             default:
 280                 alSetError(Context, AL_INVALID_ENUM);
 281                 break;
 282             }
 283         }
 284         else if(ALEffect->type == AL_EFFECT_REVERB)
 285         {
 286             switch(param)
 287             {
 288             case AL_REVERB_DECAY_HFLIMIT:
 289                 alEffecti(effect, param, piValues[0]);
 290                 break;
 291
 292             default:
 293                 alSetError(Context, AL_INVALID_ENUM);
 294                 break;
 295             }
 296         }
 297         else if(ALEffect->type == AL_EFFECT_ECHO)
 298         {
 299             switch(param)
 300             {
 301             default:
 302                 alSetError(Context, AL_INVALID_ENUM);
 303                 break;
 304             }
 305         }
 306         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
 307         {
 308             switch(param)
 309             {
 310             case AL_RING_MODULATOR_FREQUENCY:
 311             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 312             case AL_RING_MODULATOR_WAVEFORM:
 313                 alEffecti(effect, param, piValues[0]);
 314                 break;
 315
 316             default:
 317                 alSetError(Context, AL_INVALID_ENUM);
 318                 break;
 319             }
 320         }
 321         else
 322             alSetError(Context, AL_INVALID_ENUM);
 323     }
 324     else
 325         alSetError(Context, AL_INVALID_NAME);
 326
 327     ProcessContext(Context);
 328 }
 329
 330 AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
 331 {
 332     ALCcontext *Context;
 333     ALCdevice  *Device;
 334     ALeffect   *ALEffect;
 335
 336     Context = GetContextSuspended();
 337     if(!Context) return;
 338
 339     Device = Context->Device;
 340     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 341     {
 342         if(ALEffect->type == AL_EFFECT_EAXREVERB)
 343         {
 344             switch(param)
 345             {
 346             case AL_EAXREVERB_DENSITY:
 347                 if(flValue >= AL_EAXREVERB_MIN_DENSITY &&
 348                    flValue <= AL_EAXREVERB_MAX_DENSITY)
 349                     ALEffect->Reverb.Density = flValue;
 350                 else
 351                     alSetError(Context, AL_INVALID_VALUE);
 352                 break;
 353
 354             case AL_EAXREVERB_DIFFUSION:
 355                 if(flValue >= AL_EAXREVERB_MIN_DIFFUSION &&
 356                    flValue <= AL_EAXREVERB_MAX_DIFFUSION)
 357                     ALEffect->Reverb.Diffusion = flValue;
 358                 else
 359                     alSetError(Context, AL_INVALID_VALUE);
 360                 break;
 361
 362             case AL_EAXREVERB_GAIN:
 363                 if(flValue >= AL_EAXREVERB_MIN_GAIN &&
 364                    flValue <= AL_EAXREVERB_MAX_GAIN)
 365                     ALEffect->Reverb.Gain = flValue;
 366                 else
 367                     alSetError(Context, AL_INVALID_VALUE);
 368                 break;
 369
 370             case AL_EAXREVERB_GAINHF:
 371                 if(flValue >= AL_EAXREVERB_MIN_GAINHF &&
 372                    flValue <= AL_EAXREVERB_MAX_GAIN)
 373                     ALEffect->Reverb.GainHF = flValue;
 374                 else
 375                     alSetError(Context, AL_INVALID_VALUE);
 376                 break;
 377
 378             case AL_EAXREVERB_GAINLF:
 379                 if(flValue >= AL_EAXREVERB_MIN_GAINLF &&
 380                    flValue <= AL_EAXREVERB_MAX_GAINLF)
 381                     ALEffect->Reverb.GainLF = flValue;
 382                 else
 383                     alSetError(Context, AL_INVALID_VALUE);
 384                 break;
 385
 386             case AL_EAXREVERB_DECAY_TIME:
 387                 if(flValue >= AL_EAXREVERB_MIN_DECAY_TIME &&
 388                    flValue <= AL_EAXREVERB_MAX_DECAY_TIME)
 389                     ALEffect->Reverb.DecayTime = flValue;
 390                 else
 391                     alSetError(Context, AL_INVALID_VALUE);
 392                 break;
 393
 394             case AL_EAXREVERB_DECAY_HFRATIO:
 395                 if(flValue >= AL_EAXREVERB_MIN_DECAY_HFRATIO &&
 396                    flValue <= AL_EAXREVERB_MAX_DECAY_HFRATIO)
 397                     ALEffect->Reverb.DecayHFRatio = flValue;
 398                 else
 399                     alSetError(Context, AL_INVALID_VALUE);
 400                 break;
 401
 402             case AL_EAXREVERB_DECAY_LFRATIO:
 403                 if(flValue >= AL_EAXREVERB_MIN_DECAY_LFRATIO &&
 404                    flValue <= AL_EAXREVERB_MAX_DECAY_LFRATIO)
 405                     ALEffect->Reverb.DecayLFRatio = flValue;
 406                 else
 407                     alSetError(Context, AL_INVALID_VALUE);
 408                 break;
 409
 410             case AL_EAXREVERB_REFLECTIONS_GAIN:
 411                 if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN &&
 412                    flValue <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN)
 413                     ALEffect->Reverb.ReflectionsGain = flValue;
 414                 else
 415                     alSetError(Context, AL_INVALID_VALUE);
 416                 break;
 417
 418             case AL_EAXREVERB_REFLECTIONS_DELAY:
 419                 if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY &&
 420                    flValue <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY)
 421                     ALEffect->Reverb.ReflectionsDelay = flValue;
 422                 else
 423                     alSetError(Context, AL_INVALID_VALUE);
 424                 break;
 425
 426             case AL_EAXREVERB_LATE_REVERB_GAIN:
 427                 if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN &&
 428                    flValue <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN)
 429                     ALEffect->Reverb.LateReverbGain = flValue;
 430                 else
 431                     alSetError(Context, AL_INVALID_VALUE);
 432                 break;
 433
 434             case AL_EAXREVERB_LATE_REVERB_DELAY:
 435                 if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY &&
 436                    flValue <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY)
 437                     ALEffect->Reverb.LateReverbDelay = flValue;
 438                 else
 439                     alSetError(Context, AL_INVALID_VALUE);
 440                 break;
 441
 442             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 443                 if(flValue >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF &&
 444                    flValue <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF)
 445                     ALEffect->Reverb.AirAbsorptionGainHF = flValue;
 446                 else
 447                     alSetError(Context, AL_INVALID_VALUE);
 448                 break;
 449
 450             case AL_EAXREVERB_ECHO_TIME:
 451                 if(flValue >= AL_EAXREVERB_MIN_ECHO_TIME &&
 452                    flValue <= AL_EAXREVERB_MAX_ECHO_TIME)
 453                     ALEffect->Reverb.EchoTime = flValue;
 454                 else
 455                     alSetError(Context, AL_INVALID_VALUE);
 456                 break;
 457
 458             case AL_EAXREVERB_ECHO_DEPTH:
 459                 if(flValue >= AL_EAXREVERB_MIN_ECHO_DEPTH &&
 460                    flValue <= AL_EAXREVERB_MAX_ECHO_DEPTH)
 461                     ALEffect->Reverb.EchoDepth = flValue;
 462                 else
 463                     alSetError(Context, AL_INVALID_VALUE);
 464                 break;
 465
 466             case AL_EAXREVERB_MODULATION_TIME:
 467                 if(flValue >= AL_EAXREVERB_MIN_MODULATION_TIME &&
 468                    flValue <= AL_EAXREVERB_MAX_MODULATION_TIME)
 469                     ALEffect->Reverb.ModulationTime = flValue;
 470                 else
 471                     alSetError(Context, AL_INVALID_VALUE);
 472                 break;
 473
 474             case AL_EAXREVERB_MODULATION_DEPTH:
 475                 if(flValue >= AL_EAXREVERB_MIN_MODULATION_DEPTH &&
 476                    flValue <= AL_EAXREVERB_MAX_MODULATION_DEPTH)
 477                     ALEffect->Reverb.ModulationDepth = flValue;
 478                 else
 479                     alSetError(Context, AL_INVALID_VALUE);
 480                 break;
 481
 482             case AL_EAXREVERB_HFREFERENCE:
 483                 if(flValue >= AL_EAXREVERB_MIN_HFREFERENCE &&
 484                    flValue <= AL_EAXREVERB_MAX_HFREFERENCE)
 485                     ALEffect->Reverb.HFReference = flValue;
 486                 else
 487                     alSetError(Context, AL_INVALID_VALUE);
 488                 break;
 489
 490             case AL_EAXREVERB_LFREFERENCE:
 491                 if(flValue >= AL_EAXREVERB_MIN_LFREFERENCE &&
 492                    flValue <= AL_EAXREVERB_MAX_LFREFERENCE)
 493                     ALEffect->Reverb.LFReference = flValue;
 494                 else
 495                     alSetError(Context, AL_INVALID_VALUE);
 496                 break;
 497
 498             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 499                 if(flValue >= 0.0f && flValue <= 10.0f)
 500                     ALEffect->Reverb.RoomRolloffFactor = flValue;
 501                 else
 502                     alSetError(Context, AL_INVALID_VALUE);
 503                 break;
 504
 505             default:
 506                 alSetError(Context, AL_INVALID_ENUM);
 507                 break;
 508             }
 509         }
 510         else if(ALEffect->type == AL_EFFECT_REVERB)
 511         {
 512             switch(param)
 513             {
 514             case AL_REVERB_DENSITY:
 515                 if(flValue >= AL_REVERB_MIN_DENSITY &&
 516                    flValue <= AL_REVERB_MAX_DENSITY)
 517                     ALEffect->Reverb.Density = flValue;
 518                 else
 519                     alSetError(Context, AL_INVALID_VALUE);
 520                 break;
 521
 522             case AL_REVERB_DIFFUSION:
 523                 if(flValue >= AL_REVERB_MIN_DIFFUSION &&
 524                    flValue <= AL_REVERB_MAX_DIFFUSION)
 525                     ALEffect->Reverb.Diffusion = flValue;
 526                 else
 527                     alSetError(Context, AL_INVALID_VALUE);
 528                 break;
 529
 530             case AL_REVERB_GAIN:
 531                 if(flValue >= AL_REVERB_MIN_GAIN &&
 532                    flValue <= AL_REVERB_MAX_GAIN)
 533                     ALEffect->Reverb.Gain = flValue;
 534                 else
 535                     alSetError(Context, AL_INVALID_VALUE);
 536                 break;
 537
 538             case AL_REVERB_GAINHF:
 539                 if(flValue >= AL_REVERB_MIN_GAINHF &&
 540                    flValue <= AL_REVERB_MAX_GAINHF)
 541                     ALEffect->Reverb.GainHF = flValue;
 542                 else
 543                     alSetError(Context, AL_INVALID_VALUE);
 544                 break;
 545
 546             case AL_REVERB_DECAY_TIME:
 547                 if(flValue >= AL_REVERB_MIN_DECAY_TIME &&
 548                    flValue <= AL_REVERB_MAX_DECAY_TIME)
 549                     ALEffect->Reverb.DecayTime = flValue;
 550                 else
 551                     alSetError(Context, AL_INVALID_VALUE);
 552                 break;
 553
 554             case AL_REVERB_DECAY_HFRATIO:
 555                 if(flValue >= AL_REVERB_MIN_DECAY_HFRATIO &&
 556                    flValue <= AL_REVERB_MAX_DECAY_HFRATIO)
 557                     ALEffect->Reverb.DecayHFRatio = flValue;
 558                 else
 559                     alSetError(Context, AL_INVALID_VALUE);
 560                 break;
 561
 562             case AL_REVERB_REFLECTIONS_GAIN:
 563                 if(flValue >= AL_REVERB_MIN_REFLECTIONS_GAIN &&
 564                    flValue <= AL_REVERB_MAX_REFLECTIONS_GAIN)
 565                     ALEffect->Reverb.ReflectionsGain = flValue;
 566                 else
 567                     alSetError(Context, AL_INVALID_VALUE);
 568                 break;
 569
 570             case AL_REVERB_REFLECTIONS_DELAY:
 571                 if(flValue >= AL_REVERB_MIN_REFLECTIONS_DELAY &&
 572                    flValue <= AL_REVERB_MAX_REFLECTIONS_DELAY)
 573                     ALEffect->Reverb.ReflectionsDelay = flValue;
 574                 else
 575                     alSetError(Context, AL_INVALID_VALUE);
 576                 break;
 577
 578             case AL_REVERB_LATE_REVERB_GAIN:
 579                 if(flValue >= AL_REVERB_MIN_LATE_REVERB_GAIN &&
 580                    flValue <= AL_REVERB_MAX_LATE_REVERB_GAIN)
 581                     ALEffect->Reverb.LateReverbGain = flValue;
 582                 else
 583                     alSetError(Context, AL_INVALID_VALUE);
 584                 break;
 585
 586             case AL_REVERB_LATE_REVERB_DELAY:
 587                 if(flValue >= AL_REVERB_MIN_LATE_REVERB_DELAY &&
 588                    flValue <= AL_REVERB_MAX_LATE_REVERB_DELAY)
 589                     ALEffect->Reverb.LateReverbDelay = flValue;
 590                 else
 591                     alSetError(Context, AL_INVALID_VALUE);
 592                 break;
 593
 594             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 595                 if(flValue >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF &&
 596                    flValue <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF)
 597                     ALEffect->Reverb.AirAbsorptionGainHF = flValue;
 598                 else
 599                     alSetError(Context, AL_INVALID_VALUE);
 600                 break;
 601
 602             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 603                 if(flValue >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR &&
 604                    flValue <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR)
 605                     ALEffect->Reverb.RoomRolloffFactor = flValue;
 606                 else
 607                     alSetError(Context, AL_INVALID_VALUE);
 608                 break;
 609
 610             default:
 611                 alSetError(Context, AL_INVALID_ENUM);
 612                 break;
 613             }
 614         }
 615         else if(ALEffect->type == AL_EFFECT_ECHO)
 616         {
 617             switch(param)
 618             {
 619             case AL_ECHO_DELAY:
 620                 if(flValue >= AL_ECHO_MIN_DELAY && flValue <= AL_ECHO_MAX_DELAY)
 621                     ALEffect->Echo.Delay = flValue;
 622                 else
 623                     alSetError(Context, AL_INVALID_VALUE);
 624                 break;
 625
 626             case AL_ECHO_LRDELAY:
 627                 if(flValue >= AL_ECHO_MIN_LRDELAY && flValue <= AL_ECHO_MAX_LRDELAY)
 628                     ALEffect->Echo.LRDelay = flValue;
 629                 else
 630                     alSetError(Context, AL_INVALID_VALUE);
 631                 break;
 632
 633             case AL_ECHO_DAMPING:
 634                 if(flValue >= AL_ECHO_MIN_DAMPING && flValue <= AL_ECHO_MAX_DAMPING)
 635                     ALEffect->Echo.Damping = flValue;
 636                 else
 637                     alSetError(Context, AL_INVALID_VALUE);
 638                 break;
 639
 640             case AL_ECHO_FEEDBACK:
 641                 if(flValue >= AL_ECHO_MIN_FEEDBACK && flValue <= AL_ECHO_MAX_FEEDBACK)
 642                     ALEffect->Echo.Feedback = flValue;
 643                 else
 644                     alSetError(Context, AL_INVALID_VALUE);
 645                 break;
 646
 647             case AL_ECHO_SPREAD:
 648                 if(flValue >= AL_ECHO_MIN_SPREAD && flValue <= AL_ECHO_MAX_SPREAD)
 649                     ALEffect->Echo.Spread = flValue;
 650                 else
 651                     alSetError(Context, AL_INVALID_VALUE);
 652                 break;
 653
 654             default:
 655                 alSetError(Context, AL_INVALID_ENUM);
 656                 break;
 657             }
 658         }
 659         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
 660         {
 661             switch(param)
 662             {
 663             case AL_RING_MODULATOR_FREQUENCY:
 664                 if(flValue >= AL_RING_MODULATOR_MIN_FREQUENCY &&
 665                    flValue <= AL_RING_MODULATOR_MAX_FREQUENCY)
 666                     ALEffect->Modulator.Frequency = flValue;
 667                 else
 668                     alSetError(Context, AL_INVALID_VALUE);
 669                 break;
 670
 671             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 672                 if(flValue >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF &&
 673                    flValue <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF)
 674                     ALEffect->Modulator.HighPassCutoff = flValue;
 675                 else
 676                     alSetError(Context, AL_INVALID_VALUE);
 677                 break;
 678
 679             default:
 680                 alSetError(Context, AL_INVALID_ENUM);
 681                 break;
 682             }
 683         }
 684         else
 685             alSetError(Context, AL_INVALID_ENUM);
 686     }
 687     else
 688         alSetError(Context, AL_INVALID_NAME);
 689
 690     ProcessContext(Context);
 691 }
 692
 693 AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 694 {
 695     ALCcontext *Context;
 696     ALCdevice  *Device;
 697     ALeffect   *ALEffect;
 698
 699     Context = GetContextSuspended();
 700     if(!Context) return;
 701
 702     Device = Context->Device;
 703     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 704     {
 705         if(ALEffect->type == AL_EFFECT_EAXREVERB)
 706         {
 707             switch(param)
 708             {
 709             case AL_EAXREVERB_DENSITY:
 710             case AL_EAXREVERB_DIFFUSION:
 711             case AL_EAXREVERB_GAIN:
 712             case AL_EAXREVERB_GAINHF:
 713             case AL_EAXREVERB_GAINLF:
 714             case AL_EAXREVERB_DECAY_TIME:
 715             case AL_EAXREVERB_DECAY_HFRATIO:
 716             case AL_EAXREVERB_DECAY_LFRATIO:
 717             case AL_EAXREVERB_REFLECTIONS_GAIN:
 718             case AL_EAXREVERB_REFLECTIONS_DELAY:
 719             case AL_EAXREVERB_LATE_REVERB_GAIN:
 720             case AL_EAXREVERB_LATE_REVERB_DELAY:
 721             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 722             case AL_EAXREVERB_ECHO_TIME:
 723             case AL_EAXREVERB_ECHO_DEPTH:
 724             case AL_EAXREVERB_MODULATION_TIME:
 725             case AL_EAXREVERB_MODULATION_DEPTH:
 726             case AL_EAXREVERB_HFREFERENCE:
 727             case AL_EAXREVERB_LFREFERENCE:
 728             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 729                 alEffectf(effect, param, pflValues[0]);
 730                 break;
 731
 732             case AL_EAXREVERB_REFLECTIONS_PAN:
 733                 if(!isnan(pflValues[0]) && !isnan(pflValues[1]) && !isnan(pflValues[2]))
 734                 {
 735                     ALEffect->Reverb.ReflectionsPan[0] = pflValues[0];
 736                     ALEffect->Reverb.ReflectionsPan[1] = pflValues[1];
 737                     ALEffect->Reverb.ReflectionsPan[2] = pflValues[2];
 738                 }
 739                 else
 740                     alSetError(Context, AL_INVALID_VALUE);
 741                 break;
 742             case AL_EAXREVERB_LATE_REVERB_PAN:
 743                 if(!isnan(pflValues[0]) && !isnan(pflValues[1]) && !isnan(pflValues[2]))
 744                 {
 745                     ALEffect->Reverb.LateReverbPan[0] = pflValues[0];
 746                     ALEffect->Reverb.LateReverbPan[1] = pflValues[1];
 747                     ALEffect->Reverb.LateReverbPan[2] = pflValues[2];
 748                 }
 749                 else
 750                     alSetError(Context, AL_INVALID_VALUE);
 751                 break;
 752
 753             default:
 754                 alSetError(Context, AL_INVALID_ENUM);
 755                 break;
 756             }
 757         }
 758         else if(ALEffect->type == AL_EFFECT_REVERB)
 759         {
 760             switch(param)
 761             {
 762             case AL_REVERB_DENSITY:
 763             case AL_REVERB_DIFFUSION:
 764             case AL_REVERB_GAIN:
 765             case AL_REVERB_GAINHF:
 766             case AL_REVERB_DECAY_TIME:
 767             case AL_REVERB_DECAY_HFRATIO:
 768             case AL_REVERB_REFLECTIONS_GAIN:
 769             case AL_REVERB_REFLECTIONS_DELAY:
 770             case AL_REVERB_LATE_REVERB_GAIN:
 771             case AL_REVERB_LATE_REVERB_DELAY:
 772             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 773             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 774                 alEffectf(effect, param, pflValues[0]);
 775                 break;
 776
 777             default:
 778                 alSetError(Context, AL_INVALID_ENUM);
 779                 break;
 780             }
 781         }
 782         else if(ALEffect->type == AL_EFFECT_ECHO)
 783         {
 784             switch(param)
 785             {
 786             case AL_ECHO_DELAY:
 787             case AL_ECHO_LRDELAY:
 788             case AL_ECHO_DAMPING:
 789             case AL_ECHO_FEEDBACK:
 790             case AL_ECHO_SPREAD:
 791                 alEffectf(effect, param, pflValues[0]);
 792                 break;
 793
 794             default:
 795                 alSetError(Context, AL_INVALID_ENUM);
 796                 break;
 797             }
 798         }
 799         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
 800         {
 801             switch(param)
 802             {
 803             case AL_RING_MODULATOR_FREQUENCY:
 804             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 805                 alEffectf(effect, param, pflValues[0]);
 806                 break;
 807
 808             default:
 809                 alSetError(Context, AL_INVALID_ENUM);
 810                 break;
 811             }
 812         }
 813         else
 814             alSetError(Context, AL_INVALID_ENUM);
 815     }
 816     else
 817         alSetError(Context, AL_INVALID_NAME);
 818
 819     ProcessContext(Context);
 820 }
 821
 822 AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
 823 {
 824     ALCcontext *Context;
 825     ALCdevice  *Device;
 826     ALeffect   *ALEffect;
 827
 828     Context = GetContextSuspended();
 829     if(!Context) return;
 830
 831     Device = Context->Device;
 832     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 833     {
 834         if(param == AL_EFFECT_TYPE)
 835         {
 836             *piValue = ALEffect->type;
 837         }
 838         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 839         {
 840             switch(param)
 841             {
 842             case AL_EAXREVERB_DECAY_HFLIMIT:
 843                 *piValue = ALEffect->Reverb.DecayHFLimit;
 844                 break;
 845
 846             default:
 847                 alSetError(Context, AL_INVALID_ENUM);
 848                 break;
 849             }
 850         }
 851         else if(ALEffect->type == AL_EFFECT_REVERB)
 852         {
 853             switch(param)
 854             {
 855             case AL_REVERB_DECAY_HFLIMIT:
 856                 *piValue = ALEffect->Reverb.DecayHFLimit;
 857                 break;
 858
 859             default:
 860                 alSetError(Context, AL_INVALID_ENUM);
 861                 break;
 862             }
 863         }
 864         else if(ALEffect->type == AL_EFFECT_ECHO)
 865         {
 866             switch(param)
 867             {
 868             default:
 869                 alSetError(Context, AL_INVALID_ENUM);
 870                 break;
 871             }
 872         }
 873         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
 874         {
 875             switch(param)
 876             {
 877             case AL_RING_MODULATOR_FREQUENCY:
 878                 *piValue = (ALint)ALEffect->Modulator.Frequency;
 879                 break;
 880             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 881                 *piValue = (ALint)ALEffect->Modulator.HighPassCutoff;
 882                 break;
 883             case AL_RING_MODULATOR_WAVEFORM:
 884                 *piValue = ALEffect->Modulator.Waveform;
 885                 break;
 886
 887             default:
 888                 alSetError(Context, AL_INVALID_ENUM);
 889                 break;
 890             }
 891         }
 892         else
 893             alSetError(Context, AL_INVALID_ENUM);
 894     }
 895     else
 896         alSetError(Context, AL_INVALID_NAME);
 897
 898     ProcessContext(Context);
 899 }
 900
 901 AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
 902 {
 903     ALCcontext *Context;
 904     ALCdevice  *Device;
 905     ALeffect   *ALEffect;
 906
 907     Context = GetContextSuspended();
 908     if(!Context) return;
 909
 910     Device = Context->Device;
 911     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 912     {
 913         if(param == AL_EFFECT_TYPE)
 914         {
 915             alGetEffecti(effect, param, piValues);
 916         }
 917         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 918         {
 919             switch(param)
 920             {
 921             case AL_EAXREVERB_DECAY_HFLIMIT:
 922                 alGetEffecti(effect, param, piValues);
 923                 break;
 924
 925             default:
 926                 alSetError(Context, AL_INVALID_ENUM);
 927                 break;
 928             }
 929         }
 930         else if(ALEffect->type == AL_EFFECT_REVERB)
 931         {
 932             switch(param)
 933             {
 934             case AL_REVERB_DECAY_HFLIMIT:
 935                 alGetEffecti(effect, param, piValues);
 936                 break;
 937
 938             default:
 939                 alSetError(Context, AL_INVALID_ENUM);
 940                 break;
 941             }
 942         }
 943         else if(ALEffect->type == AL_EFFECT_ECHO)
 944         {
 945             switch(param)
 946             {
 947             default:
 948                 alSetError(Context, AL_INVALID_ENUM);
 949                 break;
 950             }
 951         }
 952         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
 953         {
 954             switch(param)
 955             {
 956             case AL_RING_MODULATOR_FREQUENCY:
 957             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 958             case AL_RING_MODULATOR_WAVEFORM:
 959                 alGetEffecti(effect, param, piValues);
 960                 break;
 961
 962             default:
 963                 alSetError(Context, AL_INVALID_ENUM);
 964                 break;
 965             }
 966         }
 967         else
 968             alSetError(Context, AL_INVALID_ENUM);
 969     }
 970     else
 971         alSetError(Context, AL_INVALID_NAME);
 972
 973     ProcessContext(Context);
 974 }
 975
 976 AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
 977 {
 978     ALCcontext *Context;
 979     ALCdevice  *Device;
 980     ALeffect   *ALEffect;
 981
 982     Context = GetContextSuspended();
 983     if(!Context) return;
 984
 985     Device = Context->Device;
 986     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
 987     {
 988         if(ALEffect->type == AL_EFFECT_EAXREVERB)
 989         {
 990             switch(param)
 991             {
 992             case AL_EAXREVERB_DENSITY:
 993                 *pflValue = ALEffect->Reverb.Density;
 994                 break;
 995
 996             case AL_EAXREVERB_DIFFUSION:
 997                 *pflValue = ALEffect->Reverb.Diffusion;
 998                 break;
 999
1000             case AL_EAXREVERB_GAIN:
1001                 *pflValue = ALEffect->Reverb.Gain;
1002                 break;
1003
1004             case AL_EAXREVERB_GAINHF:
1005                 *pflValue = ALEffect->Reverb.GainHF;
1006                 break;
1007
1008             case AL_EAXREVERB_GAINLF:
1009                 *pflValue = ALEffect->Reverb.GainLF;
1010                 break;
1011
1012             case AL_EAXREVERB_DECAY_TIME:
1013                 *pflValue = ALEffect->Reverb.DecayTime;
1014                 break;
1015
1016             case AL_EAXREVERB_DECAY_HFRATIO:
1017                 *pflValue = ALEffect->Reverb.DecayHFRatio;
1018                 break;
1019
1020             case AL_EAXREVERB_DECAY_LFRATIO:
1021                 *pflValue = ALEffect->Reverb.DecayLFRatio;
1022                 break;
1023
1024             case AL_EAXREVERB_REFLECTIONS_GAIN:
1025                 *pflValue = ALEffect->Reverb.ReflectionsGain;
1026                 break;
1027
1028             case AL_EAXREVERB_REFLECTIONS_DELAY:
1029                 *pflValue = ALEffect->Reverb.ReflectionsDelay;
1030                 break;
1031
1032             case AL_EAXREVERB_LATE_REVERB_GAIN:
1033                 *pflValue = ALEffect->Reverb.LateReverbGain;
1034                 break;
1035
1036             case AL_EAXREVERB_LATE_REVERB_DELAY:
1037                 *pflValue = ALEffect->Reverb.LateReverbDelay;
1038                 break;
1039
1040             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
1041                 *pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
1042                 break;
1043
1044             case AL_EAXREVERB_ECHO_TIME:
1045                 *pflValue = ALEffect->Reverb.EchoTime;
1046                 break;
1047
1048             case AL_EAXREVERB_ECHO_DEPTH:
1049                 *pflValue = ALEffect->Reverb.EchoDepth;
1050                 break;
1051
1052             case AL_EAXREVERB_MODULATION_TIME:
1053                 *pflValue = ALEffect->Reverb.ModulationTime;
1054                 break;
1055
1056             case AL_EAXREVERB_MODULATION_DEPTH:
1057                 *pflValue = ALEffect->Reverb.ModulationDepth;
1058                 break;
1059
1060             case AL_EAXREVERB_HFREFERENCE:
1061                 *pflValue = ALEffect->Reverb.HFReference;
1062                 break;
1063
1064             case AL_EAXREVERB_LFREFERENCE:
1065                 *pflValue = ALEffect->Reverb.LFReference;
1066                 break;
1067
1068             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
1069                 *pflValue = ALEffect->Reverb.RoomRolloffFactor;
1070                 break;
1071
1072             default:
1073                 alSetError(Context, AL_INVALID_ENUM);
1074                 break;
1075             }
1076         }
1077         else if(ALEffect->type == AL_EFFECT_REVERB)
1078         {
1079             switch(param)
1080             {
1081             case AL_REVERB_DENSITY:
1082                 *pflValue = ALEffect->Reverb.Density;
1083                 break;
1084
1085             case AL_REVERB_DIFFUSION:
1086                 *pflValue = ALEffect->Reverb.Diffusion;
1087                 break;
1088
1089             case AL_REVERB_GAIN:
1090                 *pflValue = ALEffect->Reverb.Gain;
1091                 break;
1092
1093             case AL_REVERB_GAINHF:
1094                 *pflValue = ALEffect->Reverb.GainHF;
1095                 break;
1096
1097             case AL_REVERB_DECAY_TIME:
1098                 *pflValue = ALEffect->Reverb.DecayTime;
1099                 break;
1100
1101             case AL_REVERB_DECAY_HFRATIO:
1102                 *pflValue = ALEffect->Reverb.DecayHFRatio;
1103                 break;
1104
1105             case AL_REVERB_REFLECTIONS_GAIN:
1106                 *pflValue = ALEffect->Reverb.ReflectionsGain;
1107                 break;
1108
1109             case AL_REVERB_REFLECTIONS_DELAY:
1110                 *pflValue = ALEffect->Reverb.ReflectionsDelay;
1111                 break;
1112
1113             case AL_REVERB_LATE_REVERB_GAIN:
1114                 *pflValue = ALEffect->Reverb.LateReverbGain;
1115                 break;
1116
1117             case AL_REVERB_LATE_REVERB_DELAY:
1118                 *pflValue = ALEffect->Reverb.LateReverbDelay;
1119                 break;
1120
1121             case AL_REVERB_AIR_ABSORPTION_GAINHF:
1122                 *pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
1123                 break;
1124
1125             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
1126                 *pflValue = ALEffect->Reverb.RoomRolloffFactor;
1127                 break;
1128
1129             default:
1130                 alSetError(Context, AL_INVALID_ENUM);
1131                 break;
1132             }
1133         }
1134         else if(ALEffect->type == AL_EFFECT_ECHO)
1135         {
1136             switch(param)
1137             {
1138             case AL_ECHO_DELAY:
1139                 *pflValue = ALEffect->Echo.Delay;
1140                 break;
1141
1142             case AL_ECHO_LRDELAY:
1143                 *pflValue = ALEffect->Echo.LRDelay;
1144                 break;
1145
1146             case AL_ECHO_DAMPING:
1147                 *pflValue = ALEffect->Echo.Damping;
1148                 break;
1149
1150             case AL_ECHO_FEEDBACK:
1151                 *pflValue = ALEffect->Echo.Feedback;
1152                 break;
1153
1154             case AL_ECHO_SPREAD:
1155                 *pflValue = ALEffect->Echo.Spread;
1156                 break;
1157
1158             default:
1159                 alSetError(Context, AL_INVALID_ENUM);
1160                 break;
1161             }
1162         }
1163         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
1164         {
1165             switch(param)
1166             {
1167             case AL_RING_MODULATOR_FREQUENCY:
1168                 *pflValue = ALEffect->Modulator.Frequency;
1169                 break;
1170             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
1171                 *pflValue = ALEffect->Modulator.HighPassCutoff;
1172                 break;
1173
1174             default:
1175                 alSetError(Context, AL_INVALID_ENUM);
1176                 break;
1177             }
1178         }
1179         else
1180             alSetError(Context, AL_INVALID_ENUM);
1181     }
1182     else
1183         alSetError(Context, AL_INVALID_NAME);
1184
1185     ProcessContext(Context);
1186 }
1187
1188 AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
1189 {
1190     ALCcontext *Context;
1191     ALCdevice  *Device;
1192     ALeffect   *ALEffect;
1193
1194     Context = GetContextSuspended();
1195     if(!Context) return;
1196
1197     Device = Context->Device;
1198     if((ALEffect=LookupEffect(Device->EffectMap, effect)) != NULL)
1199     {
1200         if(ALEffect->type == AL_EFFECT_EAXREVERB)
1201         {
1202             switch(param)
1203             {
1204             case AL_EAXREVERB_DENSITY:
1205             case AL_EAXREVERB_DIFFUSION:
1206             case AL_EAXREVERB_GAIN:
1207             case AL_EAXREVERB_GAINHF:
1208             case AL_EAXREVERB_GAINLF:
1209             case AL_EAXREVERB_DECAY_TIME:
1210             case AL_EAXREVERB_DECAY_HFRATIO:
1211             case AL_EAXREVERB_DECAY_LFRATIO:
1212             case AL_EAXREVERB_REFLECTIONS_GAIN:
1213             case AL_EAXREVERB_REFLECTIONS_DELAY:
1214             case AL_EAXREVERB_LATE_REVERB_GAIN:
1215             case AL_EAXREVERB_LATE_REVERB_DELAY:
1216             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
1217             case AL_EAXREVERB_ECHO_TIME:
1218             case AL_EAXREVERB_ECHO_DEPTH:
1219             case AL_EAXREVERB_MODULATION_TIME:
1220             case AL_EAXREVERB_MODULATION_DEPTH:
1221             case AL_EAXREVERB_HFREFERENCE:
1222             case AL_EAXREVERB_LFREFERENCE:
1223             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
1224                 alGetEffectf(effect, param, pflValues);
1225                 break;
1226
1227             case AL_EAXREVERB_REFLECTIONS_PAN:
1228                 pflValues[0] = ALEffect->Reverb.ReflectionsPan[0];
1229                 pflValues[1] = ALEffect->Reverb.ReflectionsPan[1];
1230                 pflValues[2] = ALEffect->Reverb.ReflectionsPan[2];
1231                 break;
1232             case AL_EAXREVERB_LATE_REVERB_PAN:
1233                 pflValues[0] = ALEffect->Reverb.LateReverbPan[0];
1234                 pflValues[1] = ALEffect->Reverb.LateReverbPan[1];
1235                 pflValues[2] = ALEffect->Reverb.LateReverbPan[2];
1236                 break;
1237
1238             default:
1239                 alSetError(Context, AL_INVALID_ENUM);
1240                 break;
1241             }
1242         }
1243         else if(ALEffect->type == AL_EFFECT_REVERB)
1244         {
1245             switch(param)
1246             {
1247             case AL_REVERB_DENSITY:
1248             case AL_REVERB_DIFFUSION:
1249             case AL_REVERB_GAIN:
1250             case AL_REVERB_GAINHF:
1251             case AL_REVERB_DECAY_TIME:
1252             case AL_REVERB_DECAY_HFRATIO:
1253             case AL_REVERB_REFLECTIONS_GAIN:
1254             case AL_REVERB_REFLECTIONS_DELAY:
1255             case AL_REVERB_LATE_REVERB_GAIN:
1256             case AL_REVERB_LATE_REVERB_DELAY:
1257             case AL_REVERB_AIR_ABSORPTION_GAINHF:
1258             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
1259                 alGetEffectf(effect, param, pflValues);
1260                 break;
1261
1262             default:
1263                 alSetError(Context, AL_INVALID_ENUM);
1264                 break;
1265             }
1266         }
1267         else if(ALEffect->type == AL_EFFECT_ECHO)
1268         {
1269             switch(param)
1270             {
1271             case AL_ECHO_DELAY:
1272             case AL_ECHO_LRDELAY:
1273             case AL_ECHO_DAMPING:
1274             case AL_ECHO_FEEDBACK:
1275             case AL_ECHO_SPREAD:
1276                 alGetEffectf(effect, param, pflValues);
1277                 break;
1278
1279             default:
1280                 alSetError(Context, AL_INVALID_ENUM);
1281                 break;
1282             }
1283         }
1284         else if(ALEffect->type == AL_EFFECT_RING_MODULATOR)
1285         {
1286             switch(param)
1287             {
1288             case AL_RING_MODULATOR_FREQUENCY:
1289             case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
1290                 alGetEffectf(effect, param, pflValues);
1291                 break;
1292
1293             default:
1294                 alSetError(Context, AL_INVALID_ENUM);
1295                 break;
1296             }
1297         }
1298         else
1299             alSetError(Context, AL_INVALID_ENUM);
1300     }
1301     else
1302         alSetError(Context, AL_INVALID_NAME);
1303
1304     ProcessContext(Context);
1305 }
1306
1307
1308 ALvoid ReleaseALEffects(ALCdevice *device)
1309 {
1310     ALsizei i;
1311     for(i = 0;i < device->EffectMap.size;i++)
1312     {
1313         ALeffect *temp = device->EffectMap.array[i].value;
1314         device->EffectMap.array[i].value = NULL;
1315
1316         // Release effect structure
1317         ALTHUNK_REMOVEENTRY(temp->effect);
1318         memset(temp, 0, sizeof(ALeffect));
1319         free(temp);
1320     }
1321 }
1322
1323
1324 static void InitEffectParams(ALeffect *effect, ALenum type)
1325 {
1326     effect->type = type;
1327     switch(type)
1328     {
1329     /* NOTE: Standard reverb and EAX reverb use the same defaults for the
1330      *       shared parameters, and EAX's additional parameters default to
1331      *       values assumed by standard reverb.
1332      */
1333     case AL_EFFECT_EAXREVERB:
1334     case AL_EFFECT_REVERB:
1335         effect->Reverb.Density = AL_EAXREVERB_DEFAULT_DENSITY;
1336         effect->Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
1337         effect->Reverb.Gain = AL_EAXREVERB_DEFAULT_GAIN;
1338         effect->Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF;
1339         effect->Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF;
1340         effect->Reverb.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME;
1341         effect->Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
1342         effect->Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
1343         effect->Reverb.ReflectionsGain = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN;
1344         effect->Reverb.ReflectionsDelay = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY;
1345         effect->Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
1346         effect->Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
1347         effect->Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
1348         effect->Reverb.LateReverbGain = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN;
1349         effect->Reverb.LateReverbDelay = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY;
1350         effect->Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
1351         effect->Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
1352         effect->Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
1353         effect->Reverb.EchoTime = AL_EAXREVERB_DEFAULT_ECHO_TIME;
1354         effect->Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH;
1355         effect->Reverb.ModulationTime = AL_EAXREVERB_DEFAULT_MODULATION_TIME;
1356         effect->Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH;
1357         effect->Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
1358         effect->Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
1359         effect->Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
1360         effect->Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
1361         effect->Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT;
1362         break;
1363     case AL_EFFECT_ECHO:
1364         effect->Echo.Delay = AL_ECHO_DEFAULT_DELAY;
1365         effect->Echo.LRDelay = AL_ECHO_DEFAULT_LRDELAY;
1366         effect->Echo.Damping = AL_ECHO_DEFAULT_DAMPING;
1367         effect->Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK;
1368         effect->Echo.Spread = AL_ECHO_DEFAULT_SPREAD;
1369         break;
1370     case AL_EFFECT_RING_MODULATOR:
1371         effect->Modulator.Frequency = AL_RING_MODULATOR_DEFAULT_FREQUENCY;
1372         effect->Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF;
1373         effect->Modulator.Waveform = AL_RING_MODULATOR_DEFAULT_WAVEFORM;
1374         break;
1375     }
1376 }