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