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