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