al/effects/reverb.cpp

   1
   2 #include "config.h"
   3
   4 #include <cmath>
   5
   6 #include "AL/al.h"
   7 #include "AL/efx.h"
   8
   9 #include "alc/effects/base.h"
  10 #include "effects.h"
  11
  12 #ifdef ALSOFT_EAX
  13 #include <tuple>
  14 #include "alnumeric.h"
  15 #include "AL/efx-presets.h"
  16 #include "al/eax_exception.h"
  17 #include "al/eax_utils.h"
  18 #endif // ALSOFT_EAX
  19
  20
  21 namespace {
  22
  23 void Reverb_setParami(EffectProps *props, ALenum param, int val)
  24 {
  25     switch(param)
  26     {
  27     case AL_EAXREVERB_DECAY_HFLIMIT:
  28         if(!(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT))
  29             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay hflimit out of range"};
  30         props->Reverb.DecayHFLimit = val != AL_FALSE;
  31         break;
  32
  33     default:
  34         throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
  35             param};
  36     }
  37 }
  38 void Reverb_setParamiv(EffectProps *props, ALenum param, const int *vals)
  39 { Reverb_setParami(props, param, vals[0]); }
  40 void Reverb_setParamf(EffectProps *props, ALenum param, float val)
  41 {
  42     switch(param)
  43     {
  44     case AL_EAXREVERB_DENSITY:
  45         if(!(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY))
  46             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb density out of range"};
  47         props->Reverb.Density = val;
  48         break;
  49
  50     case AL_EAXREVERB_DIFFUSION:
  51         if(!(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION))
  52             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb diffusion out of range"};
  53         props->Reverb.Diffusion = val;
  54         break;
  55
  56     case AL_EAXREVERB_GAIN:
  57         if(!(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN))
  58             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb gain out of range"};
  59         props->Reverb.Gain = val;
  60         break;
  61
  62     case AL_EAXREVERB_GAINHF:
  63         if(!(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF))
  64             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb gainhf out of range"};
  65         props->Reverb.GainHF = val;
  66         break;
  67
  68     case AL_EAXREVERB_GAINLF:
  69         if(!(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF))
  70             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb gainlf out of range"};
  71         props->Reverb.GainLF = val;
  72         break;
  73
  74     case AL_EAXREVERB_DECAY_TIME:
  75         if(!(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME))
  76             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay time out of range"};
  77         props->Reverb.DecayTime = val;
  78         break;
  79
  80     case AL_EAXREVERB_DECAY_HFRATIO:
  81         if(!(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO))
  82             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay hfratio out of range"};
  83         props->Reverb.DecayHFRatio = val;
  84         break;
  85
  86     case AL_EAXREVERB_DECAY_LFRATIO:
  87         if(!(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO))
  88             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb decay lfratio out of range"};
  89         props->Reverb.DecayLFRatio = val;
  90         break;
  91
  92     case AL_EAXREVERB_REFLECTIONS_GAIN:
  93         if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN))
  94             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb reflections gain out of range"};
  95         props->Reverb.ReflectionsGain = val;
  96         break;
  97
  98     case AL_EAXREVERB_REFLECTIONS_DELAY:
  99         if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY))
 100             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb reflections delay out of range"};
 101         props->Reverb.ReflectionsDelay = val;
 102         break;
 103
 104     case AL_EAXREVERB_LATE_REVERB_GAIN:
 105         if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN && val <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN))
 106             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb late reverb gain out of range"};
 107         props->Reverb.LateReverbGain = val;
 108         break;
 109
 110     case AL_EAXREVERB_LATE_REVERB_DELAY:
 111         if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY && val <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY))
 112             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb late reverb delay out of range"};
 113         props->Reverb.LateReverbDelay = val;
 114         break;
 115
 116     case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 117         if(!(val >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF))
 118             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb air absorption gainhf out of range"};
 119         props->Reverb.AirAbsorptionGainHF = val;
 120         break;
 121
 122     case AL_EAXREVERB_ECHO_TIME:
 123         if(!(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME))
 124             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb echo time out of range"};
 125         props->Reverb.EchoTime = val;
 126         break;
 127
 128     case AL_EAXREVERB_ECHO_DEPTH:
 129         if(!(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH))
 130             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb echo depth out of range"};
 131         props->Reverb.EchoDepth = val;
 132         break;
 133
 134     case AL_EAXREVERB_MODULATION_TIME:
 135         if(!(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME))
 136             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb modulation time out of range"};
 137         props->Reverb.ModulationTime = val;
 138         break;
 139
 140     case AL_EAXREVERB_MODULATION_DEPTH:
 141         if(!(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH))
 142             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb modulation depth out of range"};
 143         props->Reverb.ModulationDepth = val;
 144         break;
 145
 146     case AL_EAXREVERB_HFREFERENCE:
 147         if(!(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE))
 148             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb hfreference out of range"};
 149         props->Reverb.HFReference = val;
 150         break;
 151
 152     case AL_EAXREVERB_LFREFERENCE:
 153         if(!(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE))
 154             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb lfreference out of range"};
 155         props->Reverb.LFReference = val;
 156         break;
 157
 158     case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 159         if(!(val >= AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR))
 160             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb room rolloff factor out of range"};
 161         props->Reverb.RoomRolloffFactor = val;
 162         break;
 163
 164     default:
 165         throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x", param};
 166     }
 167 }
 168 void Reverb_setParamfv(EffectProps *props, ALenum param, const float *vals)
 169 {
 170     switch(param)
 171     {
 172     case AL_EAXREVERB_REFLECTIONS_PAN:
 173         if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
 174             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb reflections pan out of range"};
 175         props->Reverb.ReflectionsPan[0] = vals[0];
 176         props->Reverb.ReflectionsPan[1] = vals[1];
 177         props->Reverb.ReflectionsPan[2] = vals[2];
 178         break;
 179     case AL_EAXREVERB_LATE_REVERB_PAN:
 180         if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
 181             throw effect_exception{AL_INVALID_VALUE, "EAX Reverb late reverb pan out of range"};
 182         props->Reverb.LateReverbPan[0] = vals[0];
 183         props->Reverb.LateReverbPan[1] = vals[1];
 184         props->Reverb.LateReverbPan[2] = vals[2];
 185         break;
 186
 187     default:
 188         Reverb_setParamf(props, param, vals[0]);
 189         break;
 190     }
 191 }
 192
 193 void Reverb_getParami(const EffectProps *props, ALenum param, int *val)
 194 {
 195     switch(param)
 196     {
 197     case AL_EAXREVERB_DECAY_HFLIMIT:
 198         *val = props->Reverb.DecayHFLimit;
 199         break;
 200
 201     default:
 202         throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
 203             param};
 204     }
 205 }
 206 void Reverb_getParamiv(const EffectProps *props, ALenum param, int *vals)
 207 { Reverb_getParami(props, param, vals); }
 208 void Reverb_getParamf(const EffectProps *props, ALenum param, float *val)
 209 {
 210     switch(param)
 211     {
 212     case AL_EAXREVERB_DENSITY:
 213         *val = props->Reverb.Density;
 214         break;
 215
 216     case AL_EAXREVERB_DIFFUSION:
 217         *val = props->Reverb.Diffusion;
 218         break;
 219
 220     case AL_EAXREVERB_GAIN:
 221         *val = props->Reverb.Gain;
 222         break;
 223
 224     case AL_EAXREVERB_GAINHF:
 225         *val = props->Reverb.GainHF;
 226         break;
 227
 228     case AL_EAXREVERB_GAINLF:
 229         *val = props->Reverb.GainLF;
 230         break;
 231
 232     case AL_EAXREVERB_DECAY_TIME:
 233         *val = props->Reverb.DecayTime;
 234         break;
 235
 236     case AL_EAXREVERB_DECAY_HFRATIO:
 237         *val = props->Reverb.DecayHFRatio;
 238         break;
 239
 240     case AL_EAXREVERB_DECAY_LFRATIO:
 241         *val = props->Reverb.DecayLFRatio;
 242         break;
 243
 244     case AL_EAXREVERB_REFLECTIONS_GAIN:
 245         *val = props->Reverb.ReflectionsGain;
 246         break;
 247
 248     case AL_EAXREVERB_REFLECTIONS_DELAY:
 249         *val = props->Reverb.ReflectionsDelay;
 250         break;
 251
 252     case AL_EAXREVERB_LATE_REVERB_GAIN:
 253         *val = props->Reverb.LateReverbGain;
 254         break;
 255
 256     case AL_EAXREVERB_LATE_REVERB_DELAY:
 257         *val = props->Reverb.LateReverbDelay;
 258         break;
 259
 260     case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 261         *val = props->Reverb.AirAbsorptionGainHF;
 262         break;
 263
 264     case AL_EAXREVERB_ECHO_TIME:
 265         *val = props->Reverb.EchoTime;
 266         break;
 267
 268     case AL_EAXREVERB_ECHO_DEPTH:
 269         *val = props->Reverb.EchoDepth;
 270         break;
 271
 272     case AL_EAXREVERB_MODULATION_TIME:
 273         *val = props->Reverb.ModulationTime;
 274         break;
 275
 276     case AL_EAXREVERB_MODULATION_DEPTH:
 277         *val = props->Reverb.ModulationDepth;
 278         break;
 279
 280     case AL_EAXREVERB_HFREFERENCE:
 281         *val = props->Reverb.HFReference;
 282         break;
 283
 284     case AL_EAXREVERB_LFREFERENCE:
 285         *val = props->Reverb.LFReference;
 286         break;
 287
 288     case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 289         *val = props->Reverb.RoomRolloffFactor;
 290         break;
 291
 292     default:
 293         throw effect_exception{AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x", param};
 294     }
 295 }
 296 void Reverb_getParamfv(const EffectProps *props, ALenum param, float *vals)
 297 {
 298     switch(param)
 299     {
 300     case AL_EAXREVERB_REFLECTIONS_PAN:
 301         vals[0] = props->Reverb.ReflectionsPan[0];
 302         vals[1] = props->Reverb.ReflectionsPan[1];
 303         vals[2] = props->Reverb.ReflectionsPan[2];
 304         break;
 305     case AL_EAXREVERB_LATE_REVERB_PAN:
 306         vals[0] = props->Reverb.LateReverbPan[0];
 307         vals[1] = props->Reverb.LateReverbPan[1];
 308         vals[2] = props->Reverb.LateReverbPan[2];
 309         break;
 310
 311     default:
 312         Reverb_getParamf(props, param, vals);
 313         break;
 314     }
 315 }
 316
 317 EffectProps genDefaultProps() noexcept
 318 {
 319     EffectProps props{};
 320     props.Reverb.Density   = AL_EAXREVERB_DEFAULT_DENSITY;
 321     props.Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
 322     props.Reverb.Gain   = AL_EAXREVERB_DEFAULT_GAIN;
 323     props.Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF;
 324     props.Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF;
 325     props.Reverb.DecayTime    = AL_EAXREVERB_DEFAULT_DECAY_TIME;
 326     props.Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
 327     props.Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
 328     props.Reverb.ReflectionsGain   = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN;
 329     props.Reverb.ReflectionsDelay  = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY;
 330     props.Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
 331     props.Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
 332     props.Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
 333     props.Reverb.LateReverbGain   = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN;
 334     props.Reverb.LateReverbDelay  = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY;
 335     props.Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
 336     props.Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
 337     props.Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
 338     props.Reverb.EchoTime  = AL_EAXREVERB_DEFAULT_ECHO_TIME;
 339     props.Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH;
 340     props.Reverb.ModulationTime  = AL_EAXREVERB_DEFAULT_MODULATION_TIME;
 341     props.Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH;
 342     props.Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
 343     props.Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
 344     props.Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
 345     props.Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
 346     props.Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT;
 347     return props;
 348 }
 349
 350
 351 void StdReverb_setParami(EffectProps *props, ALenum param, int val)
 352 {
 353     switch(param)
 354     {
 355     case AL_REVERB_DECAY_HFLIMIT:
 356         if(!(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT))
 357             throw effect_exception{AL_INVALID_VALUE, "Reverb decay hflimit out of range"};
 358         props->Reverb.DecayHFLimit = val != AL_FALSE;
 359         break;
 360
 361     default:
 362         throw effect_exception{AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param};
 363     }
 364 }
 365 void StdReverb_setParamiv(EffectProps *props, ALenum param, const int *vals)
 366 { StdReverb_setParami(props, param, vals[0]); }
 367 void StdReverb_setParamf(EffectProps *props, ALenum param, float val)
 368 {
 369     switch(param)
 370     {
 371     case AL_REVERB_DENSITY:
 372         if(!(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY))
 373             throw effect_exception{AL_INVALID_VALUE, "Reverb density out of range"};
 374         props->Reverb.Density = val;
 375         break;
 376
 377     case AL_REVERB_DIFFUSION:
 378         if(!(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION))
 379             throw effect_exception{AL_INVALID_VALUE, "Reverb diffusion out of range"};
 380         props->Reverb.Diffusion = val;
 381         break;
 382
 383     case AL_REVERB_GAIN:
 384         if(!(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN))
 385             throw effect_exception{AL_INVALID_VALUE, "Reverb gain out of range"};
 386         props->Reverb.Gain = val;
 387         break;
 388
 389     case AL_REVERB_GAINHF:
 390         if(!(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF))
 391             throw effect_exception{AL_INVALID_VALUE, "Reverb gainhf out of range"};
 392         props->Reverb.GainHF = val;
 393         break;
 394
 395     case AL_REVERB_DECAY_TIME:
 396         if(!(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME))
 397             throw effect_exception{AL_INVALID_VALUE, "Reverb decay time out of range"};
 398         props->Reverb.DecayTime = val;
 399         break;
 400
 401     case AL_REVERB_DECAY_HFRATIO:
 402         if(!(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO))
 403             throw effect_exception{AL_INVALID_VALUE, "Reverb decay hfratio out of range"};
 404         props->Reverb.DecayHFRatio = val;
 405         break;
 406
 407     case AL_REVERB_REFLECTIONS_GAIN:
 408         if(!(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN))
 409             throw effect_exception{AL_INVALID_VALUE, "Reverb reflections gain out of range"};
 410         props->Reverb.ReflectionsGain = val;
 411         break;
 412
 413     case AL_REVERB_REFLECTIONS_DELAY:
 414         if(!(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY))
 415             throw effect_exception{AL_INVALID_VALUE, "Reverb reflections delay out of range"};
 416         props->Reverb.ReflectionsDelay = val;
 417         break;
 418
 419     case AL_REVERB_LATE_REVERB_GAIN:
 420         if(!(val >= AL_REVERB_MIN_LATE_REVERB_GAIN && val <= AL_REVERB_MAX_LATE_REVERB_GAIN))
 421             throw effect_exception{AL_INVALID_VALUE, "Reverb late reverb gain out of range"};
 422         props->Reverb.LateReverbGain = val;
 423         break;
 424
 425     case AL_REVERB_LATE_REVERB_DELAY:
 426         if(!(val >= AL_REVERB_MIN_LATE_REVERB_DELAY && val <= AL_REVERB_MAX_LATE_REVERB_DELAY))
 427             throw effect_exception{AL_INVALID_VALUE, "Reverb late reverb delay out of range"};
 428         props->Reverb.LateReverbDelay = val;
 429         break;
 430
 431     case AL_REVERB_AIR_ABSORPTION_GAINHF:
 432         if(!(val >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF))
 433             throw effect_exception{AL_INVALID_VALUE, "Reverb air absorption gainhf out of range"};
 434         props->Reverb.AirAbsorptionGainHF = val;
 435         break;
 436
 437     case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 438         if(!(val >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR))
 439             throw effect_exception{AL_INVALID_VALUE, "Reverb room rolloff factor out of range"};
 440         props->Reverb.RoomRolloffFactor = val;
 441         break;
 442
 443     default:
 444         throw effect_exception{AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param};
 445     }
 446 }
 447 void StdReverb_setParamfv(EffectProps *props, ALenum param, const float *vals)
 448 { StdReverb_setParamf(props, param, vals[0]); }
 449
 450 void StdReverb_getParami(const EffectProps *props, ALenum param, int *val)
 451 {
 452     switch(param)
 453     {
 454     case AL_REVERB_DECAY_HFLIMIT:
 455         *val = props->Reverb.DecayHFLimit;
 456         break;
 457
 458     default:
 459         throw effect_exception{AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param};
 460     }
 461 }
 462 void StdReverb_getParamiv(const EffectProps *props, ALenum param, int *vals)
 463 { StdReverb_getParami(props, param, vals); }
 464 void StdReverb_getParamf(const EffectProps *props, ALenum param, float *val)
 465 {
 466     switch(param)
 467     {
 468     case AL_REVERB_DENSITY:
 469         *val = props->Reverb.Density;
 470         break;
 471
 472     case AL_REVERB_DIFFUSION:
 473         *val = props->Reverb.Diffusion;
 474         break;
 475
 476     case AL_REVERB_GAIN:
 477         *val = props->Reverb.Gain;
 478         break;
 479
 480     case AL_REVERB_GAINHF:
 481         *val = props->Reverb.GainHF;
 482         break;
 483
 484     case AL_REVERB_DECAY_TIME:
 485         *val = props->Reverb.DecayTime;
 486         break;
 487
 488     case AL_REVERB_DECAY_HFRATIO:
 489         *val = props->Reverb.DecayHFRatio;
 490         break;
 491
 492     case AL_REVERB_REFLECTIONS_GAIN:
 493         *val = props->Reverb.ReflectionsGain;
 494         break;
 495
 496     case AL_REVERB_REFLECTIONS_DELAY:
 497         *val = props->Reverb.ReflectionsDelay;
 498         break;
 499
 500     case AL_REVERB_LATE_REVERB_GAIN:
 501         *val = props->Reverb.LateReverbGain;
 502         break;
 503
 504     case AL_REVERB_LATE_REVERB_DELAY:
 505         *val = props->Reverb.LateReverbDelay;
 506         break;
 507
 508     case AL_REVERB_AIR_ABSORPTION_GAINHF:
 509         *val = props->Reverb.AirAbsorptionGainHF;
 510         break;
 511
 512     case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 513         *val = props->Reverb.RoomRolloffFactor;
 514         break;
 515
 516     default:
 517         throw effect_exception{AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param};
 518     }
 519 }
 520 void StdReverb_getParamfv(const EffectProps *props, ALenum param, float *vals)
 521 { StdReverb_getParamf(props, param, vals); }
 522
 523 EffectProps genDefaultStdProps() noexcept
 524 {
 525     EffectProps props{};
 526     props.Reverb.Density   = AL_REVERB_DEFAULT_DENSITY;
 527     props.Reverb.Diffusion = AL_REVERB_DEFAULT_DIFFUSION;
 528     props.Reverb.Gain   = AL_REVERB_DEFAULT_GAIN;
 529     props.Reverb.GainHF = AL_REVERB_DEFAULT_GAINHF;
 530     props.Reverb.GainLF = 1.0f;
 531     props.Reverb.DecayTime    = AL_REVERB_DEFAULT_DECAY_TIME;
 532     props.Reverb.DecayHFRatio = AL_REVERB_DEFAULT_DECAY_HFRATIO;
 533     props.Reverb.DecayLFRatio = 1.0f;
 534     props.Reverb.ReflectionsGain   = AL_REVERB_DEFAULT_REFLECTIONS_GAIN;
 535     props.Reverb.ReflectionsDelay  = AL_REVERB_DEFAULT_REFLECTIONS_DELAY;
 536     props.Reverb.ReflectionsPan[0] = 0.0f;
 537     props.Reverb.ReflectionsPan[1] = 0.0f;
 538     props.Reverb.ReflectionsPan[2] = 0.0f;
 539     props.Reverb.LateReverbGain   = AL_REVERB_DEFAULT_LATE_REVERB_GAIN;
 540     props.Reverb.LateReverbDelay  = AL_REVERB_DEFAULT_LATE_REVERB_DELAY;
 541     props.Reverb.LateReverbPan[0] = 0.0f;
 542     props.Reverb.LateReverbPan[1] = 0.0f;
 543     props.Reverb.LateReverbPan[2] = 0.0f;
 544     props.Reverb.EchoTime  = 0.25f;
 545     props.Reverb.EchoDepth = 0.0f;
 546     props.Reverb.ModulationTime  = 0.25f;
 547     props.Reverb.ModulationDepth = 0.0f;
 548     props.Reverb.AirAbsorptionGainHF = AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
 549     props.Reverb.HFReference = 5000.0f;
 550     props.Reverb.LFReference = 250.0f;
 551     props.Reverb.RoomRolloffFactor = AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
 552     props.Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT;
 553     return props;
 554 }
 555
 556 } // namespace
 557
 558 DEFINE_ALEFFECT_VTABLE(Reverb);
 559
 560 const EffectProps ReverbEffectProps{genDefaultProps()};
 561
 562 DEFINE_ALEFFECT_VTABLE(StdReverb);
 563
 564 const EffectProps StdReverbEffectProps{genDefaultStdProps()};
 565
 566 #ifdef ALSOFT_EAX
 567 namespace {
 568
 569 extern const EFXEAXREVERBPROPERTIES eax_efx_reverb_presets[];
 570
 571 using EaxReverbEffectDirtyFlagsValue = std::uint_least32_t;
 572
 573 struct EaxReverbEffectDirtyFlags
 574 {
 575     using EaxIsBitFieldStruct = bool;
 576
 577     EaxReverbEffectDirtyFlagsValue ulEnvironment : 1;
 578     EaxReverbEffectDirtyFlagsValue flEnvironmentSize : 1;
 579     EaxReverbEffectDirtyFlagsValue flEnvironmentDiffusion : 1;
 580     EaxReverbEffectDirtyFlagsValue lRoom : 1;
 581     EaxReverbEffectDirtyFlagsValue lRoomHF : 1;
 582     EaxReverbEffectDirtyFlagsValue lRoomLF : 1;
 583     EaxReverbEffectDirtyFlagsValue flDecayTime : 1;
 584     EaxReverbEffectDirtyFlagsValue flDecayHFRatio : 1;
 585     EaxReverbEffectDirtyFlagsValue flDecayLFRatio : 1;
 586     EaxReverbEffectDirtyFlagsValue lReflections : 1;
 587     EaxReverbEffectDirtyFlagsValue flReflectionsDelay : 1;
 588     EaxReverbEffectDirtyFlagsValue vReflectionsPan : 1;
 589     EaxReverbEffectDirtyFlagsValue lReverb : 1;
 590     EaxReverbEffectDirtyFlagsValue flReverbDelay : 1;
 591     EaxReverbEffectDirtyFlagsValue vReverbPan : 1;
 592     EaxReverbEffectDirtyFlagsValue flEchoTime : 1;
 593     EaxReverbEffectDirtyFlagsValue flEchoDepth : 1;
 594     EaxReverbEffectDirtyFlagsValue flModulationTime : 1;
 595     EaxReverbEffectDirtyFlagsValue flModulationDepth : 1;
 596     EaxReverbEffectDirtyFlagsValue flAirAbsorptionHF : 1;
 597     EaxReverbEffectDirtyFlagsValue flHFReference : 1;
 598     EaxReverbEffectDirtyFlagsValue flLFReference : 1;
 599     EaxReverbEffectDirtyFlagsValue flRoomRolloffFactor : 1;
 600     EaxReverbEffectDirtyFlagsValue ulFlags : 1;
 601 }; // EaxReverbEffectDirtyFlags
 602
 603 class EaxReverbEffect final :
 604     public EaxEffect
 605 {
 606 public:
 607     EaxReverbEffect();
 608
 609     // [[nodiscard]]
 610     bool dispatch(
 611         const EaxEaxCall& eax_call) override;
 612
 613 private:
 614     EAX_REVERBPROPERTIES eax1_{};
 615     EAXREVERBPROPERTIES eax_{};
 616     EAXREVERBPROPERTIES eax_d_{};
 617     EaxReverbEffectDirtyFlags eax_dirty_flags_{};
 618
 619     [[noreturn]] static void eax_fail(const char* message);
 620
 621     void set_eax_defaults();
 622
 623
 624     void set_efx_density_from_environment_size();
 625
 626     void set_efx_diffusion();
 627
 628     void set_efx_gain();
 629
 630     void set_efx_gain_hf();
 631
 632     void set_efx_gain_lf();
 633
 634     void set_efx_decay_time();
 635
 636     void set_efx_decay_hf_ratio();
 637
 638     void set_efx_decay_lf_ratio();
 639
 640     void set_efx_reflections_gain();
 641
 642     void set_efx_reflections_delay();
 643
 644     void set_efx_reflections_pan();
 645
 646     void set_efx_late_reverb_gain();
 647
 648     void set_efx_late_reverb_delay();
 649
 650     void set_efx_late_reverb_pan();
 651
 652     void set_efx_echo_time();
 653
 654     void set_efx_echo_depth();
 655
 656     void set_efx_modulation_time();
 657
 658     void set_efx_modulation_depth();
 659
 660     void set_efx_air_absorption_gain_hf();
 661
 662     void set_efx_hf_reference();
 663
 664     void set_efx_lf_reference();
 665
 666     void set_efx_room_rolloff_factor();
 667
 668     void set_efx_flags();
 669
 670     void set_efx_defaults();
 671
 672
 673     bool v1_get(const EaxEaxCall& eax_call) const;
 674
 675     void get_all(
 676         const EaxEaxCall& eax_call) const;
 677
 678     // [[nodiscard]]
 679     bool get(
 680         const EaxEaxCall& eax_call) const;
 681
 682
 683     static void v1_validate_environment(unsigned long environment);
 684     static void v1_validate_volume(float volume);
 685     static void v1_validate_decay_time(float decay_time);
 686     static void v1_validate_damping(float damping);
 687     static void v1_validate_all(const EAX_REVERBPROPERTIES& all);
 688
 689     static void validate_environment(
 690         unsigned long ulEnvironment,
 691         int version,
 692         bool is_standalone);
 693
 694     static void validate_environment_size(
 695         float flEnvironmentSize);
 696
 697     static void validate_environment_diffusion(
 698         float flEnvironmentDiffusion);
 699
 700     static void validate_room(
 701         long lRoom);
 702
 703     static void validate_room_hf(
 704         long lRoomHF);
 705
 706     static void validate_room_lf(
 707         long lRoomLF);
 708
 709     static void validate_decay_time(
 710         float flDecayTime);
 711
 712     static void validate_decay_hf_ratio(
 713         float flDecayHFRatio);
 714
 715     static void validate_decay_lf_ratio(
 716         float flDecayLFRatio);
 717
 718     static void validate_reflections(
 719         long lReflections);
 720
 721     static void validate_reflections_delay(
 722         float flReflectionsDelay);
 723
 724     static void validate_reflections_pan(
 725         const EAXVECTOR& vReflectionsPan);
 726
 727     static void validate_reverb(
 728         long lReverb);
 729
 730     static void validate_reverb_delay(
 731         float flReverbDelay);
 732
 733     static void validate_reverb_pan(
 734         const EAXVECTOR& vReverbPan);
 735
 736     static void validate_echo_time(
 737         float flEchoTime);
 738
 739     static void validate_echo_depth(
 740         float flEchoDepth);
 741
 742     static void validate_modulation_time(
 743         float flModulationTime);
 744
 745     static void validate_modulation_depth(
 746         float flModulationDepth);
 747
 748     static void validate_air_absorbtion_hf(
 749         float air_absorbtion_hf);
 750
 751     static void validate_hf_reference(
 752         float flHFReference);
 753
 754     static void validate_lf_reference(
 755         float flLFReference);
 756
 757     static void validate_room_rolloff_factor(
 758         float flRoomRolloffFactor);
 759
 760     static void validate_flags(
 761         unsigned long ulFlags);
 762
 763     static void validate_all(
 764         const EAX20LISTENERPROPERTIES& all,
 765         int version);
 766
 767     static void validate_all(
 768         const EAXREVERBPROPERTIES& all,
 769         int version);
 770
 771
 772     void defer_environment(
 773         unsigned long ulEnvironment);
 774
 775     void defer_environment_size(
 776         float flEnvironmentSize);
 777
 778     void defer_environment_diffusion(
 779         float flEnvironmentDiffusion);
 780
 781     void defer_room(
 782         long lRoom);
 783
 784     void defer_room_hf(
 785         long lRoomHF);
 786
 787     void defer_room_lf(
 788         long lRoomLF);
 789
 790     void defer_decay_time(
 791         float flDecayTime);
 792
 793     void defer_decay_hf_ratio(
 794         float flDecayHFRatio);
 795
 796     void defer_decay_lf_ratio(
 797         float flDecayLFRatio);
 798
 799     void defer_reflections(
 800         long lReflections);
 801
 802     void defer_reflections_delay(
 803         float flReflectionsDelay);
 804
 805     void defer_reflections_pan(
 806         const EAXVECTOR& vReflectionsPan);
 807
 808     void defer_reverb(
 809         long lReverb);
 810
 811     void defer_reverb_delay(
 812         float flReverbDelay);
 813
 814     void defer_reverb_pan(
 815         const EAXVECTOR& vReverbPan);
 816
 817     void defer_echo_time(
 818         float flEchoTime);
 819
 820     void defer_echo_depth(
 821         float flEchoDepth);
 822
 823     void defer_modulation_time(
 824         float flModulationTime);
 825
 826     void defer_modulation_depth(
 827         float flModulationDepth);
 828
 829     void defer_air_absorbtion_hf(
 830         float flAirAbsorptionHF);
 831
 832     void defer_hf_reference(
 833         float flHFReference);
 834
 835     void defer_lf_reference(
 836         float flLFReference);
 837
 838     void defer_room_rolloff_factor(
 839         float flRoomRolloffFactor);
 840
 841     void defer_flags(
 842         unsigned long ulFlags);
 843
 844     void defer_all(
 845         const EAX20LISTENERPROPERTIES& all);
 846
 847     void defer_all(
 848         const EAXREVERBPROPERTIES& all);
 849
 850
 851     void defer_environment(
 852         const EaxEaxCall& eax_call);
 853
 854     void defer_environment_size(
 855         const EaxEaxCall& eax_call);
 856
 857     void defer_environment_diffusion(
 858         const EaxEaxCall& eax_call);
 859
 860     void defer_room(
 861         const EaxEaxCall& eax_call);
 862
 863     void defer_room_hf(
 864         const EaxEaxCall& eax_call);
 865
 866     void defer_room_lf(
 867         const EaxEaxCall& eax_call);
 868
 869     void defer_decay_time(
 870         const EaxEaxCall& eax_call);
 871
 872     void defer_decay_hf_ratio(
 873         const EaxEaxCall& eax_call);
 874
 875     void defer_decay_lf_ratio(
 876         const EaxEaxCall& eax_call);
 877
 878     void defer_reflections(
 879         const EaxEaxCall& eax_call);
 880
 881     void defer_reflections_delay(
 882         const EaxEaxCall& eax_call);
 883
 884     void defer_reflections_pan(
 885         const EaxEaxCall& eax_call);
 886
 887     void defer_reverb(
 888         const EaxEaxCall& eax_call);
 889
 890     void defer_reverb_delay(
 891         const EaxEaxCall& eax_call);
 892
 893     void defer_reverb_pan(
 894         const EaxEaxCall& eax_call);
 895
 896     void defer_echo_time(
 897         const EaxEaxCall& eax_call);
 898
 899     void defer_echo_depth(
 900         const EaxEaxCall& eax_call);
 901
 902     void defer_modulation_time(
 903         const EaxEaxCall& eax_call);
 904
 905     void defer_modulation_depth(
 906         const EaxEaxCall& eax_call);
 907
 908     void defer_air_absorbtion_hf(
 909         const EaxEaxCall& eax_call);
 910
 911     void defer_hf_reference(
 912         const EaxEaxCall& eax_call);
 913
 914     void defer_lf_reference(
 915         const EaxEaxCall& eax_call);
 916
 917     void defer_room_rolloff_factor(
 918         const EaxEaxCall& eax_call);
 919
 920     void defer_flags(
 921         const EaxEaxCall& eax_call);
 922
 923     void defer_all(
 924         const EaxEaxCall& eax_call);
 925
 926
 927     void v1_set_efx();
 928     bool v1_set_environment(const EaxEaxCall& eax_call);
 929     bool v1_set_volume(const EaxEaxCall& eax_call);
 930     bool v1_set_decay_time(const EaxEaxCall& eax_call);
 931     bool v1_set_damping(const EaxEaxCall& eax_call);
 932     bool v1_set_all(const EaxEaxCall& eax_call);
 933     bool v1_set(const EaxEaxCall& eax_call);
 934
 935     // [[nodiscard]]
 936     bool apply_deferred();
 937
 938     // [[nodiscard]]
 939     bool set(
 940         const EaxEaxCall& eax_call);
 941 }; // EaxReverbEffect
 942
 943
 944 class EaxReverbEffectException :
 945     public EaxException
 946 {
 947 public:
 948     explicit EaxReverbEffectException(
 949         const char* message)
 950         :
 951         EaxException{"EAX_REVERB_EFFECT", message}
 952     {
 953     }
 954 }; // EaxReverbEffectException
 955
 956
 957 EaxReverbEffect::EaxReverbEffect()
 958     : EaxEffect{AL_EFFECT_EAXREVERB}
 959 {
 960     set_eax_defaults();
 961     set_efx_defaults();
 962 }
 963
 964 // [[nodiscard]]
 965 bool EaxReverbEffect::dispatch(
 966     const EaxEaxCall& eax_call)
 967 {
 968     return eax_call.is_get() ? get(eax_call) : set(eax_call);
 969 }
 970
 971 [[noreturn]] void EaxReverbEffect::eax_fail(const char* message)
 972 {
 973     throw EaxReverbEffectException{message};
 974 }
 975
 976 void EaxReverbEffect::set_eax_defaults()
 977 {
 978     eax1_ = EAX1REVERB_PRESETS[EAX_ENVIRONMENT_GENERIC];
 979     eax_ = EAXREVERB_PRESETS[EAX_ENVIRONMENT_GENERIC];
 980     eax_d_ = eax_;
 981 }
 982
 983 void EaxReverbEffect::set_efx_density_from_environment_size()
 984 {
 985     const auto eax_environment_size = eax_.flEnvironmentSize;
 986
 987     const auto efx_density = clamp(
 988         (eax_environment_size * eax_environment_size * eax_environment_size) / 16.0F,
 989         AL_EAXREVERB_MIN_DENSITY,
 990         AL_EAXREVERB_MAX_DENSITY);
 991
 992     al_effect_props_.Reverb.Density = efx_density;
 993 }
 994
 995 void EaxReverbEffect::set_efx_diffusion()
 996 {
 997     const auto efx_diffusion = clamp(
 998         eax_.flEnvironmentDiffusion,
 999         AL_EAXREVERB_MIN_DIFFUSION,
1000         AL_EAXREVERB_MAX_DIFFUSION);
1001
1002     al_effect_props_.Reverb.Diffusion = efx_diffusion;
1003 }
1004
1005 void EaxReverbEffect::set_efx_gain()
1006 {
1007     const auto efx_gain = clamp(
1008         level_mb_to_gain(static_cast<float>(eax_.lRoom)),
1009         AL_EAXREVERB_MIN_GAIN,
1010         AL_EAXREVERB_MAX_GAIN);
1011
1012     al_effect_props_.Reverb.Gain = efx_gain;
1013 }
1014
1015 void EaxReverbEffect::set_efx_gain_hf()
1016 {
1017     const auto efx_gain_hf = clamp(
1018         level_mb_to_gain(static_cast<float>(eax_.lRoomHF)),
1019         AL_EAXREVERB_MIN_GAINHF,
1020         AL_EAXREVERB_MAX_GAINHF);
1021
1022     al_effect_props_.Reverb.GainHF = efx_gain_hf;
1023 }
1024
1025 void EaxReverbEffect::set_efx_gain_lf()
1026 {
1027     const auto efx_gain_lf = clamp(
1028         level_mb_to_gain(static_cast<float>(eax_.lRoomLF)),
1029         AL_EAXREVERB_MIN_GAINLF,
1030         AL_EAXREVERB_MAX_GAINLF);
1031
1032     al_effect_props_.Reverb.GainLF = efx_gain_lf;
1033 }
1034
1035 void EaxReverbEffect::set_efx_decay_time()
1036 {
1037     const auto efx_decay_time = clamp(
1038         eax_.flDecayTime,
1039         AL_EAXREVERB_MIN_DECAY_TIME,
1040         AL_EAXREVERB_MAX_DECAY_TIME);
1041
1042     al_effect_props_.Reverb.DecayTime = efx_decay_time;
1043 }
1044
1045 void EaxReverbEffect::set_efx_decay_hf_ratio()
1046 {
1047     const auto efx_decay_hf_ratio = clamp(
1048         eax_.flDecayHFRatio,
1049         AL_EAXREVERB_MIN_DECAY_HFRATIO,
1050         AL_EAXREVERB_MAX_DECAY_HFRATIO);
1051
1052     al_effect_props_.Reverb.DecayHFRatio = efx_decay_hf_ratio;
1053 }
1054
1055 void EaxReverbEffect::set_efx_decay_lf_ratio()
1056 {
1057     const auto efx_decay_lf_ratio = clamp(
1058         eax_.flDecayLFRatio,
1059         AL_EAXREVERB_MIN_DECAY_LFRATIO,
1060         AL_EAXREVERB_MAX_DECAY_LFRATIO);
1061
1062     al_effect_props_.Reverb.DecayLFRatio = efx_decay_lf_ratio;
1063 }
1064
1065 void EaxReverbEffect::set_efx_reflections_gain()
1066 {
1067     const auto efx_reflections_gain = clamp(
1068         level_mb_to_gain(static_cast<float>(eax_.lReflections)),
1069         AL_EAXREVERB_MIN_REFLECTIONS_GAIN,
1070         AL_EAXREVERB_MAX_REFLECTIONS_GAIN);
1071
1072     al_effect_props_.Reverb.ReflectionsGain = efx_reflections_gain;
1073 }
1074
1075 void EaxReverbEffect::set_efx_reflections_delay()
1076 {
1077     const auto efx_reflections_delay = clamp(
1078         eax_.flReflectionsDelay,
1079         AL_EAXREVERB_MIN_REFLECTIONS_DELAY,
1080         AL_EAXREVERB_MAX_REFLECTIONS_DELAY);
1081
1082     al_effect_props_.Reverb.ReflectionsDelay = efx_reflections_delay;
1083 }
1084
1085 void EaxReverbEffect::set_efx_reflections_pan()
1086 {
1087     al_effect_props_.Reverb.ReflectionsPan[0] = eax_.vReflectionsPan.x;
1088     al_effect_props_.Reverb.ReflectionsPan[1] = eax_.vReflectionsPan.y;
1089     al_effect_props_.Reverb.ReflectionsPan[2] = eax_.vReflectionsPan.z;
1090 }
1091
1092 void EaxReverbEffect::set_efx_late_reverb_gain()
1093 {
1094     const auto efx_late_reverb_gain = clamp(
1095         level_mb_to_gain(static_cast<float>(eax_.lReverb)),
1096         AL_EAXREVERB_MIN_LATE_REVERB_GAIN,
1097         AL_EAXREVERB_MAX_LATE_REVERB_GAIN);
1098
1099     al_effect_props_.Reverb.LateReverbGain = efx_late_reverb_gain;
1100 }
1101
1102 void EaxReverbEffect::set_efx_late_reverb_delay()
1103 {
1104     const auto efx_late_reverb_delay = clamp(
1105         eax_.flReverbDelay,
1106         AL_EAXREVERB_MIN_LATE_REVERB_DELAY,
1107         AL_EAXREVERB_MAX_LATE_REVERB_DELAY);
1108
1109     al_effect_props_.Reverb.LateReverbDelay = efx_late_reverb_delay;
1110 }
1111
1112 void EaxReverbEffect::set_efx_late_reverb_pan()
1113 {
1114     al_effect_props_.Reverb.LateReverbPan[0] = eax_.vReverbPan.x;
1115     al_effect_props_.Reverb.LateReverbPan[1] = eax_.vReverbPan.y;
1116     al_effect_props_.Reverb.LateReverbPan[2] = eax_.vReverbPan.z;
1117 }
1118
1119 void EaxReverbEffect::set_efx_echo_time()
1120 {
1121     const auto efx_echo_time = clamp(
1122         eax_.flEchoTime,
1123         AL_EAXREVERB_MIN_ECHO_TIME,
1124         AL_EAXREVERB_MAX_ECHO_TIME);
1125
1126     al_effect_props_.Reverb.EchoTime = efx_echo_time;
1127 }
1128
1129 void EaxReverbEffect::set_efx_echo_depth()
1130 {
1131     const auto efx_echo_depth = clamp(
1132         eax_.flEchoDepth,
1133         AL_EAXREVERB_MIN_ECHO_DEPTH,
1134         AL_EAXREVERB_MAX_ECHO_DEPTH);
1135
1136     al_effect_props_.Reverb.EchoDepth = efx_echo_depth;
1137 }
1138
1139 void EaxReverbEffect::set_efx_modulation_time()
1140 {
1141     const auto efx_modulation_time = clamp(
1142         eax_.flModulationTime,
1143         AL_EAXREVERB_MIN_MODULATION_TIME,
1144         AL_EAXREVERB_MAX_MODULATION_TIME);
1145
1146     al_effect_props_.Reverb.ModulationTime = efx_modulation_time;
1147 }
1148
1149 void EaxReverbEffect::set_efx_modulation_depth()
1150 {
1151     const auto efx_modulation_depth = clamp(
1152         eax_.flModulationDepth,
1153         AL_EAXREVERB_MIN_MODULATION_DEPTH,
1154         AL_EAXREVERB_MAX_MODULATION_DEPTH);
1155
1156     al_effect_props_.Reverb.ModulationDepth = efx_modulation_depth;
1157 }
1158
1159 void EaxReverbEffect::set_efx_air_absorption_gain_hf()
1160 {
1161     const auto efx_air_absorption_hf = clamp(
1162         level_mb_to_gain(eax_.flAirAbsorptionHF),
1163         AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF,
1164         AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF);
1165
1166     al_effect_props_.Reverb.AirAbsorptionGainHF = efx_air_absorption_hf;
1167 }
1168
1169 void EaxReverbEffect::set_efx_hf_reference()
1170 {
1171     const auto efx_hf_reference = clamp(
1172         eax_.flHFReference,
1173         AL_EAXREVERB_MIN_HFREFERENCE,
1174         AL_EAXREVERB_MAX_HFREFERENCE);
1175
1176     al_effect_props_.Reverb.HFReference = efx_hf_reference;
1177 }
1178
1179 void EaxReverbEffect::set_efx_lf_reference()
1180 {
1181     const auto efx_lf_reference = clamp(
1182         eax_.flLFReference,
1183         AL_EAXREVERB_MIN_LFREFERENCE,
1184         AL_EAXREVERB_MAX_LFREFERENCE);
1185
1186     al_effect_props_.Reverb.LFReference = efx_lf_reference;
1187 }
1188
1189 void EaxReverbEffect::set_efx_room_rolloff_factor()
1190 {
1191     const auto efx_room_rolloff_factor = clamp(
1192         eax_.flRoomRolloffFactor,
1193         AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR,
1194         AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR);
1195
1196     al_effect_props_.Reverb.RoomRolloffFactor = efx_room_rolloff_factor;
1197 }
1198
1199 void EaxReverbEffect::set_efx_flags()
1200 {
1201     al_effect_props_.Reverb.DecayHFLimit = ((eax_.ulFlags & EAXREVERBFLAGS_DECAYHFLIMIT) != 0);
1202 }
1203
1204 void EaxReverbEffect::set_efx_defaults()
1205 {
1206     set_efx_density_from_environment_size();
1207     set_efx_diffusion();
1208     set_efx_gain();
1209     set_efx_gain_hf();
1210     set_efx_gain_lf();
1211     set_efx_decay_time();
1212     set_efx_decay_hf_ratio();
1213     set_efx_decay_lf_ratio();
1214     set_efx_reflections_gain();
1215     set_efx_reflections_delay();
1216     set_efx_reflections_pan();
1217     set_efx_late_reverb_gain();
1218     set_efx_late_reverb_delay();
1219     set_efx_late_reverb_pan();
1220     set_efx_echo_time();
1221     set_efx_echo_depth();
1222     set_efx_modulation_time();
1223     set_efx_modulation_depth();
1224     set_efx_air_absorption_gain_hf();
1225     set_efx_hf_reference();
1226     set_efx_lf_reference();
1227     set_efx_room_rolloff_factor();
1228     set_efx_flags();
1229 }
1230
1231 bool EaxReverbEffect::v1_get(const EaxEaxCall& eax_call) const
1232 {
1233     switch (eax_call.get_property_id())
1234     {
1235         case DSPROPERTY_EAX_ALL:
1236             eax_call.set_value<EaxReverbEffectException>(eax1_);
1237             break;
1238
1239         case DSPROPERTY_EAX_ENVIRONMENT:
1240             eax_call.set_value<EaxReverbEffectException>(eax1_.environment);
1241             break;
1242
1243         case DSPROPERTY_EAX_VOLUME:
1244             eax_call.set_value<EaxReverbEffectException>(eax1_.fVolume);
1245             break;
1246
1247         case DSPROPERTY_EAX_DECAYTIME:
1248             eax_call.set_value<EaxReverbEffectException>(eax1_.fDecayTime_sec);
1249             break;
1250
1251         case DSPROPERTY_EAX_DAMPING:
1252             eax_call.set_value<EaxReverbEffectException>(eax1_.fDamping);
1253             break;
1254
1255         default:
1256             eax_fail("Unsupported property id.");
1257     }
1258
1259     return false;
1260 }
1261
1262 void EaxReverbEffect::get_all(
1263     const EaxEaxCall& eax_call) const
1264 {
1265     if (eax_call.get_version() == 2)
1266     {
1267         auto& eax_reverb = eax_call.get_value<EaxReverbEffectException, EAX20LISTENERPROPERTIES>();
1268         eax_reverb.lRoom = eax_.lRoom;
1269         eax_reverb.lRoomHF = eax_.lRoomHF;
1270         eax_reverb.flRoomRolloffFactor = eax_.flRoomRolloffFactor;
1271         eax_reverb.flDecayTime = eax_.flDecayTime;
1272         eax_reverb.flDecayHFRatio = eax_.flDecayHFRatio;
1273         eax_reverb.lReflections = eax_.lReflections;
1274         eax_reverb.flReflectionsDelay = eax_.flReflectionsDelay;
1275         eax_reverb.lReverb = eax_.lReverb;
1276         eax_reverb.flReverbDelay = eax_.flReverbDelay;
1277         eax_reverb.dwEnvironment = eax_.ulEnvironment;
1278         eax_reverb.flEnvironmentSize = eax_.flEnvironmentSize;
1279         eax_reverb.flEnvironmentDiffusion = eax_.flEnvironmentDiffusion;
1280         eax_reverb.flAirAbsorptionHF = eax_.flAirAbsorptionHF;
1281         eax_reverb.dwFlags = eax_.ulFlags;
1282     }
1283     else
1284     {
1285         eax_call.set_value<EaxReverbEffectException>(eax_);
1286     }
1287 }
1288
1289 // [[nodiscard]]
1290 bool EaxReverbEffect::get(
1291     const EaxEaxCall& eax_call) const
1292 {
1293     if (eax_call.get_version() == 1)
1294         return v1_get(eax_call);
1295
1296     switch (eax_call.get_property_id())
1297     {
1298         case EAXREVERB_NONE:
1299             break;
1300
1301         case EAXREVERB_ALLPARAMETERS:
1302             get_all(eax_call);
1303             break;
1304
1305         case EAXREVERB_ENVIRONMENT:
1306             eax_call.set_value<EaxReverbEffectException>(eax_.ulEnvironment);
1307             break;
1308
1309         case EAXREVERB_ENVIRONMENTSIZE:
1310             eax_call.set_value<EaxReverbEffectException>(eax_.flEnvironmentSize);
1311             break;
1312
1313         case EAXREVERB_ENVIRONMENTDIFFUSION:
1314             eax_call.set_value<EaxReverbEffectException>(eax_.flEnvironmentDiffusion);
1315             break;
1316
1317         case EAXREVERB_ROOM:
1318             eax_call.set_value<EaxReverbEffectException>(eax_.lRoom);
1319             break;
1320
1321         case EAXREVERB_ROOMHF:
1322             eax_call.set_value<EaxReverbEffectException>(eax_.lRoomHF);
1323             break;
1324
1325         case EAXREVERB_ROOMLF:
1326             eax_call.set_value<EaxReverbEffectException>(eax_.lRoomLF);
1327             break;
1328
1329         case EAXREVERB_DECAYTIME:
1330             eax_call.set_value<EaxReverbEffectException>(eax_.flDecayTime);
1331             break;
1332
1333         case EAXREVERB_DECAYHFRATIO:
1334             eax_call.set_value<EaxReverbEffectException>(eax_.flDecayHFRatio);
1335             break;
1336
1337         case EAXREVERB_DECAYLFRATIO:
1338             eax_call.set_value<EaxReverbEffectException>(eax_.flDecayLFRatio);
1339             break;
1340
1341         case EAXREVERB_REFLECTIONS:
1342             eax_call.set_value<EaxReverbEffectException>(eax_.lReflections);
1343             break;
1344
1345         case EAXREVERB_REFLECTIONSDELAY:
1346             eax_call.set_value<EaxReverbEffectException>(eax_.flReflectionsDelay);
1347             break;
1348
1349         case EAXREVERB_REFLECTIONSPAN:
1350             eax_call.set_value<EaxReverbEffectException>(eax_.vReflectionsPan);
1351             break;
1352
1353         case EAXREVERB_REVERB:
1354             eax_call.set_value<EaxReverbEffectException>(eax_.lReverb);
1355             break;
1356
1357         case EAXREVERB_REVERBDELAY:
1358             eax_call.set_value<EaxReverbEffectException>(eax_.flReverbDelay);
1359             break;
1360
1361         case EAXREVERB_REVERBPAN:
1362             eax_call.set_value<EaxReverbEffectException>(eax_.vReverbPan);
1363             break;
1364
1365         case EAXREVERB_ECHOTIME:
1366             eax_call.set_value<EaxReverbEffectException>(eax_.flEchoTime);
1367             break;
1368
1369         case EAXREVERB_ECHODEPTH:
1370             eax_call.set_value<EaxReverbEffectException>(eax_.flEchoDepth);
1371             break;
1372
1373         case EAXREVERB_MODULATIONTIME:
1374             eax_call.set_value<EaxReverbEffectException>(eax_.flModulationTime);
1375             break;
1376
1377         case EAXREVERB_MODULATIONDEPTH:
1378             eax_call.set_value<EaxReverbEffectException>(eax_.flModulationDepth);
1379             break;
1380
1381         case EAXREVERB_AIRABSORPTIONHF:
1382             eax_call.set_value<EaxReverbEffectException>(eax_.flAirAbsorptionHF);
1383             break;
1384
1385         case EAXREVERB_HFREFERENCE:
1386             eax_call.set_value<EaxReverbEffectException>(eax_.flHFReference);
1387             break;
1388
1389         case EAXREVERB_LFREFERENCE:
1390             eax_call.set_value<EaxReverbEffectException>(eax_.flLFReference);
1391             break;
1392
1393         case EAXREVERB_ROOMROLLOFFFACTOR:
1394             eax_call.set_value<EaxReverbEffectException>(eax_.flRoomRolloffFactor);
1395             break;
1396
1397         case EAXREVERB_FLAGS:
1398             eax_call.set_value<EaxReverbEffectException>(eax_.ulFlags);
1399             break;
1400
1401         default:
1402             eax_fail("Unsupported property id.");
1403     }
1404
1405     return false;
1406 }
1407
1408 void EaxReverbEffect::v1_validate_environment(unsigned long environment)
1409 {
1410     validate_environment(environment, 1, true);
1411 }
1412
1413 void EaxReverbEffect::v1_validate_volume(float volume)
1414 {
1415     eax_validate_range<EaxReverbEffectException>("Volume", volume, EAX1REVERB_MINVOLUME, EAX1REVERB_MAXVOLUME);
1416 }
1417
1418 void EaxReverbEffect::v1_validate_decay_time(float decay_time)
1419 {
1420     validate_decay_time(decay_time);
1421 }
1422
1423 void EaxReverbEffect::v1_validate_damping(float damping)
1424 {
1425     eax_validate_range<EaxReverbEffectException>("Damping", damping, EAX1REVERB_MINDAMPING, EAX1REVERB_MAXDAMPING);
1426 }
1427
1428 void EaxReverbEffect::v1_validate_all(const EAX_REVERBPROPERTIES& all)
1429 {
1430     v1_validate_environment(all.environment);
1431     v1_validate_volume(all.fVolume);
1432     v1_validate_decay_time(all.fDecayTime_sec);
1433     v1_validate_damping(all.fDamping);
1434 }
1435
1436 void EaxReverbEffect::validate_environment(
1437     unsigned long ulEnvironment,
1438     int version,
1439     bool is_standalone)
1440 {
1441     eax_validate_range<EaxReverbEffectException>(
1442         "Environment",
1443         ulEnvironment,
1444         EAXREVERB_MINENVIRONMENT,
1445         (version <= 2 || is_standalone) ? EAX1REVERB_MAXENVIRONMENT : EAX30REVERB_MAXENVIRONMENT);
1446 }
1447
1448 void EaxReverbEffect::validate_environment_size(
1449     float flEnvironmentSize)
1450 {
1451     eax_validate_range<EaxReverbEffectException>(
1452         "Environment Size",
1453         flEnvironmentSize,
1454         EAXREVERB_MINENVIRONMENTSIZE,
1455         EAXREVERB_MAXENVIRONMENTSIZE);
1456 }
1457
1458 void EaxReverbEffect::validate_environment_diffusion(
1459     float flEnvironmentDiffusion)
1460 {
1461     eax_validate_range<EaxReverbEffectException>(
1462         "Environment Diffusion",
1463         flEnvironmentDiffusion,
1464         EAXREVERB_MINENVIRONMENTDIFFUSION,
1465         EAXREVERB_MAXENVIRONMENTDIFFUSION);
1466 }
1467
1468 void EaxReverbEffect::validate_room(
1469     long lRoom)
1470 {
1471     eax_validate_range<EaxReverbEffectException>(
1472         "Room",
1473         lRoom,
1474         EAXREVERB_MINROOM,
1475         EAXREVERB_MAXROOM);
1476 }
1477
1478 void EaxReverbEffect::validate_room_hf(
1479     long lRoomHF)
1480 {
1481     eax_validate_range<EaxReverbEffectException>(
1482         "Room HF",
1483         lRoomHF,
1484         EAXREVERB_MINROOMHF,
1485         EAXREVERB_MAXROOMHF);
1486 }
1487
1488 void EaxReverbEffect::validate_room_lf(
1489     long lRoomLF)
1490 {
1491     eax_validate_range<EaxReverbEffectException>(
1492         "Room LF",
1493         lRoomLF,
1494         EAXREVERB_MINROOMLF,
1495         EAXREVERB_MAXROOMLF);
1496 }
1497
1498 void EaxReverbEffect::validate_decay_time(
1499     float flDecayTime)
1500 {
1501     eax_validate_range<EaxReverbEffectException>(
1502         "Decay Time",
1503         flDecayTime,
1504         EAXREVERB_MINDECAYTIME,
1505         EAXREVERB_MAXDECAYTIME);
1506 }
1507
1508 void EaxReverbEffect::validate_decay_hf_ratio(
1509     float flDecayHFRatio)
1510 {
1511     eax_validate_range<EaxReverbEffectException>(
1512         "Decay HF Ratio",
1513         flDecayHFRatio,
1514         EAXREVERB_MINDECAYHFRATIO,
1515         EAXREVERB_MAXDECAYHFRATIO);
1516 }
1517
1518 void EaxReverbEffect::validate_decay_lf_ratio(
1519     float flDecayLFRatio)
1520 {
1521     eax_validate_range<EaxReverbEffectException>(
1522         "Decay LF Ratio",
1523         flDecayLFRatio,
1524         EAXREVERB_MINDECAYLFRATIO,
1525         EAXREVERB_MAXDECAYLFRATIO);
1526 }
1527
1528 void EaxReverbEffect::validate_reflections(
1529     long lReflections)
1530 {
1531     eax_validate_range<EaxReverbEffectException>(
1532         "Reflections",
1533         lReflections,
1534         EAXREVERB_MINREFLECTIONS,
1535         EAXREVERB_MAXREFLECTIONS);
1536 }
1537
1538 void EaxReverbEffect::validate_reflections_delay(
1539     float flReflectionsDelay)
1540 {
1541     eax_validate_range<EaxReverbEffectException>(
1542         "Reflections Delay",
1543         flReflectionsDelay,
1544         EAXREVERB_MINREFLECTIONSDELAY,
1545         EAXREVERB_MAXREFLECTIONSDELAY);
1546 }
1547
1548 void EaxReverbEffect::validate_reflections_pan(
1549     const EAXVECTOR& vReflectionsPan)
1550 {
1551     std::ignore = vReflectionsPan;
1552 }
1553
1554 void EaxReverbEffect::validate_reverb(
1555     long lReverb)
1556 {
1557     eax_validate_range<EaxReverbEffectException>(
1558         "Reverb",
1559         lReverb,
1560         EAXREVERB_MINREVERB,
1561         EAXREVERB_MAXREVERB);
1562 }
1563
1564 void EaxReverbEffect::validate_reverb_delay(
1565     float flReverbDelay)
1566 {
1567     eax_validate_range<EaxReverbEffectException>(
1568         "Reverb Delay",
1569         flReverbDelay,
1570         EAXREVERB_MINREVERBDELAY,
1571         EAXREVERB_MAXREVERBDELAY);
1572 }
1573
1574 void EaxReverbEffect::validate_reverb_pan(
1575     const EAXVECTOR& vReverbPan)
1576 {
1577     std::ignore = vReverbPan;
1578 }
1579
1580 void EaxReverbEffect::validate_echo_time(
1581     float flEchoTime)
1582 {
1583     eax_validate_range<EaxReverbEffectException>(
1584         "Echo Time",
1585         flEchoTime,
1586         EAXREVERB_MINECHOTIME,
1587         EAXREVERB_MAXECHOTIME);
1588 }
1589
1590 void EaxReverbEffect::validate_echo_depth(
1591     float flEchoDepth)
1592 {
1593     eax_validate_range<EaxReverbEffectException>(
1594         "Echo Depth",
1595         flEchoDepth,
1596         EAXREVERB_MINECHODEPTH,
1597         EAXREVERB_MAXECHODEPTH);
1598 }
1599
1600 void EaxReverbEffect::validate_modulation_time(
1601     float flModulationTime)
1602 {
1603     eax_validate_range<EaxReverbEffectException>(
1604         "Modulation Time",
1605         flModulationTime,
1606         EAXREVERB_MINMODULATIONTIME,
1607         EAXREVERB_MAXMODULATIONTIME);
1608 }
1609
1610 void EaxReverbEffect::validate_modulation_depth(
1611     float flModulationDepth)
1612 {
1613     eax_validate_range<EaxReverbEffectException>(
1614         "Modulation Depth",
1615         flModulationDepth,
1616         EAXREVERB_MINMODULATIONDEPTH,
1617         EAXREVERB_MAXMODULATIONDEPTH);
1618 }
1619
1620 void EaxReverbEffect::validate_air_absorbtion_hf(
1621     float air_absorbtion_hf)
1622 {
1623     eax_validate_range<EaxReverbEffectException>(
1624         "Air Absorbtion HF",
1625         air_absorbtion_hf,
1626         EAXREVERB_MINAIRABSORPTIONHF,
1627         EAXREVERB_MAXAIRABSORPTIONHF);
1628 }
1629
1630 void EaxReverbEffect::validate_hf_reference(
1631     float flHFReference)
1632 {
1633     eax_validate_range<EaxReverbEffectException>(
1634         "HF Reference",
1635         flHFReference,
1636         EAXREVERB_MINHFREFERENCE,
1637         EAXREVERB_MAXHFREFERENCE);
1638 }
1639
1640 void EaxReverbEffect::validate_lf_reference(
1641     float flLFReference)
1642 {
1643     eax_validate_range<EaxReverbEffectException>(
1644         "LF Reference",
1645         flLFReference,
1646         EAXREVERB_MINLFREFERENCE,
1647         EAXREVERB_MAXLFREFERENCE);
1648 }
1649
1650 void EaxReverbEffect::validate_room_rolloff_factor(
1651     float flRoomRolloffFactor)
1652 {
1653     eax_validate_range<EaxReverbEffectException>(
1654         "Room Rolloff Factor",
1655         flRoomRolloffFactor,
1656         EAXREVERB_MINROOMROLLOFFFACTOR,
1657         EAXREVERB_MAXROOMROLLOFFFACTOR);
1658 }
1659
1660 void EaxReverbEffect::validate_flags(
1661     unsigned long ulFlags)
1662 {
1663     eax_validate_range<EaxReverbEffectException>(
1664         "Flags",
1665         ulFlags,
1666         0UL,
1667         ~EAXREVERBFLAGS_RESERVED);
1668 }
1669
1670 void EaxReverbEffect::validate_all(
1671     const EAX20LISTENERPROPERTIES& listener,
1672     int version)
1673 {
1674     validate_room(listener.lRoom);
1675     validate_room_hf(listener.lRoomHF);
1676     validate_room_rolloff_factor(listener.flRoomRolloffFactor);
1677     validate_decay_time(listener.flDecayTime);
1678     validate_decay_hf_ratio(listener.flDecayHFRatio);
1679     validate_reflections(listener.lReflections);
1680     validate_reflections_delay(listener.flReflectionsDelay);
1681     validate_reverb(listener.lReverb);
1682     validate_reverb_delay(listener.flReverbDelay);
1683     validate_environment(listener.dwEnvironment, version, false);
1684     validate_environment_size(listener.flEnvironmentSize);
1685     validate_environment_diffusion(listener.flEnvironmentDiffusion);
1686     validate_air_absorbtion_hf(listener.flAirAbsorptionHF);
1687     validate_flags(listener.dwFlags);
1688 }
1689
1690 void EaxReverbEffect::validate_all(
1691     const EAXREVERBPROPERTIES& lReverb,
1692     int version)
1693 {
1694     validate_environment(lReverb.ulEnvironment, version, false);
1695     validate_environment_size(lReverb.flEnvironmentSize);
1696     validate_environment_diffusion(lReverb.flEnvironmentDiffusion);
1697     validate_room(lReverb.lRoom);
1698     validate_room_hf(lReverb.lRoomHF);
1699     validate_room_lf(lReverb.lRoomLF);
1700     validate_decay_time(lReverb.flDecayTime);
1701     validate_decay_hf_ratio(lReverb.flDecayHFRatio);
1702     validate_decay_lf_ratio(lReverb.flDecayLFRatio);
1703     validate_reflections(lReverb.lReflections);
1704     validate_reflections_delay(lReverb.flReflectionsDelay);
1705     validate_reverb(lReverb.lReverb);
1706     validate_reverb_delay(lReverb.flReverbDelay);
1707     validate_echo_time(lReverb.flEchoTime);
1708     validate_echo_depth(lReverb.flEchoDepth);
1709     validate_modulation_time(lReverb.flModulationTime);
1710     validate_modulation_depth(lReverb.flModulationDepth);
1711     validate_air_absorbtion_hf(lReverb.flAirAbsorptionHF);
1712     validate_hf_reference(lReverb.flHFReference);
1713     validate_lf_reference(lReverb.flLFReference);
1714     validate_room_rolloff_factor(lReverb.flRoomRolloffFactor);
1715     validate_flags(lReverb.ulFlags);
1716 }
1717
1718 void EaxReverbEffect::v1_set_efx()
1719 {
1720     auto efx_props = eax_efx_reverb_presets[eax1_.environment];
1721     efx_props.flGain = eax1_.fVolume;
1722     efx_props.flDecayTime = eax1_.fDecayTime_sec;
1723     efx_props.flDecayHFRatio = clamp(eax1_.fDamping, AL_EAXREVERB_MIN_DECAY_HFRATIO, AL_EAXREVERB_MAX_DECAY_HFRATIO);
1724
1725     al_effect_props_.Reverb.Density = efx_props.flDensity;
1726     al_effect_props_.Reverb.Diffusion = efx_props.flDiffusion;
1727     al_effect_props_.Reverb.Gain = efx_props.flGain;
1728     al_effect_props_.Reverb.GainHF = efx_props.flGainHF;
1729     al_effect_props_.Reverb.GainLF = efx_props.flGainLF;
1730     al_effect_props_.Reverb.DecayTime = efx_props.flDecayTime;
1731     al_effect_props_.Reverb.DecayHFRatio = efx_props.flDecayHFRatio;
1732     al_effect_props_.Reverb.DecayLFRatio = efx_props.flDecayLFRatio;
1733     al_effect_props_.Reverb.ReflectionsGain = efx_props.flReflectionsGain;
1734     al_effect_props_.Reverb.ReflectionsDelay = efx_props.flReflectionsDelay;
1735     al_effect_props_.Reverb.ReflectionsPan[0] = efx_props.flReflectionsPan[0];
1736     al_effect_props_.Reverb.ReflectionsPan[1] = efx_props.flReflectionsPan[1];
1737     al_effect_props_.Reverb.ReflectionsPan[2] = efx_props.flReflectionsPan[2];
1738     al_effect_props_.Reverb.LateReverbGain = efx_props.flLateReverbGain;
1739     al_effect_props_.Reverb.LateReverbDelay = efx_props.flLateReverbDelay;
1740     al_effect_props_.Reverb.LateReverbPan[0] = efx_props.flLateReverbPan[0];
1741     al_effect_props_.Reverb.LateReverbPan[1] = efx_props.flLateReverbPan[1];
1742     al_effect_props_.Reverb.LateReverbPan[2] = efx_props.flLateReverbPan[2];
1743     al_effect_props_.Reverb.EchoTime = efx_props.flEchoTime;
1744     al_effect_props_.Reverb.EchoDepth = efx_props.flEchoDepth;
1745     al_effect_props_.Reverb.ModulationTime = efx_props.flModulationTime;
1746     al_effect_props_.Reverb.ModulationDepth = efx_props.flModulationDepth;
1747     al_effect_props_.Reverb.HFReference = efx_props.flHFReference;
1748     al_effect_props_.Reverb.LFReference = efx_props.flLFReference;
1749     al_effect_props_.Reverb.RoomRolloffFactor = efx_props.flRoomRolloffFactor;
1750     al_effect_props_.Reverb.AirAbsorptionGainHF = efx_props.flAirAbsorptionGainHF;
1751     al_effect_props_.Reverb.DecayHFLimit = false;
1752 }
1753
1754 void EaxReverbEffect::defer_environment(
1755     unsigned long ulEnvironment)
1756 {
1757     eax_d_.ulEnvironment = ulEnvironment;
1758     eax_dirty_flags_.ulEnvironment = (eax_.ulEnvironment != eax_d_.ulEnvironment);
1759 }
1760
1761 void EaxReverbEffect::defer_environment_size(
1762     float flEnvironmentSize)
1763 {
1764     eax_d_.flEnvironmentSize = flEnvironmentSize;
1765     eax_dirty_flags_.flEnvironmentSize = (eax_.flEnvironmentSize != eax_d_.flEnvironmentSize);
1766 }
1767
1768 void EaxReverbEffect::defer_environment_diffusion(
1769     float flEnvironmentDiffusion)
1770 {
1771     eax_d_.flEnvironmentDiffusion = flEnvironmentDiffusion;
1772     eax_dirty_flags_.flEnvironmentDiffusion = (eax_.flEnvironmentDiffusion != eax_d_.flEnvironmentDiffusion);
1773 }
1774
1775 void EaxReverbEffect::defer_room(
1776     long lRoom)
1777 {
1778     eax_d_.lRoom = lRoom;
1779     eax_dirty_flags_.lRoom = (eax_.lRoom != eax_d_.lRoom);
1780 }
1781
1782 void EaxReverbEffect::defer_room_hf(
1783     long lRoomHF)
1784 {
1785     eax_d_.lRoomHF = lRoomHF;
1786     eax_dirty_flags_.lRoomHF = (eax_.lRoomHF != eax_d_.lRoomHF);
1787 }
1788
1789 void EaxReverbEffect::defer_room_lf(
1790     long lRoomLF)
1791 {
1792     eax_d_.lRoomLF = lRoomLF;
1793     eax_dirty_flags_.lRoomLF = (eax_.lRoomLF != eax_d_.lRoomLF);
1794 }
1795
1796 void EaxReverbEffect::defer_decay_time(
1797     float flDecayTime)
1798 {
1799     eax_d_.flDecayTime = flDecayTime;
1800     eax_dirty_flags_.flDecayTime = (eax_.flDecayTime != eax_d_.flDecayTime);
1801 }
1802
1803 void EaxReverbEffect::defer_decay_hf_ratio(
1804     float flDecayHFRatio)
1805 {
1806     eax_d_.flDecayHFRatio = flDecayHFRatio;
1807     eax_dirty_flags_.flDecayHFRatio = (eax_.flDecayHFRatio != eax_d_.flDecayHFRatio);
1808 }
1809
1810 void EaxReverbEffect::defer_decay_lf_ratio(
1811     float flDecayLFRatio)
1812 {
1813     eax_d_.flDecayLFRatio = flDecayLFRatio;
1814     eax_dirty_flags_.flDecayLFRatio = (eax_.flDecayLFRatio != eax_d_.flDecayLFRatio);
1815 }
1816
1817 void EaxReverbEffect::defer_reflections(
1818     long lReflections)
1819 {
1820     eax_d_.lReflections = lReflections;
1821     eax_dirty_flags_.lReflections = (eax_.lReflections != eax_d_.lReflections);
1822 }
1823
1824 void EaxReverbEffect::defer_reflections_delay(
1825     float flReflectionsDelay)
1826 {
1827     eax_d_.flReflectionsDelay = flReflectionsDelay;
1828     eax_dirty_flags_.flReflectionsDelay = (eax_.flReflectionsDelay != eax_d_.flReflectionsDelay);
1829 }
1830
1831 void EaxReverbEffect::defer_reflections_pan(
1832     const EAXVECTOR& vReflectionsPan)
1833 {
1834     eax_d_.vReflectionsPan = vReflectionsPan;
1835     eax_dirty_flags_.vReflectionsPan = (eax_.vReflectionsPan != eax_d_.vReflectionsPan);
1836 }
1837
1838 void EaxReverbEffect::defer_reverb(
1839     long lReverb)
1840 {
1841     eax_d_.lReverb = lReverb;
1842     eax_dirty_flags_.lReverb = (eax_.lReverb != eax_d_.lReverb);
1843 }
1844
1845 void EaxReverbEffect::defer_reverb_delay(
1846     float flReverbDelay)
1847 {
1848     eax_d_.flReverbDelay = flReverbDelay;
1849     eax_dirty_flags_.flReverbDelay = (eax_.flReverbDelay != eax_d_.flReverbDelay);
1850 }
1851
1852 void EaxReverbEffect::defer_reverb_pan(
1853     const EAXVECTOR& vReverbPan)
1854 {
1855     eax_d_.vReverbPan = vReverbPan;
1856     eax_dirty_flags_.vReverbPan = (eax_.vReverbPan != eax_d_.vReverbPan);
1857 }
1858
1859 void EaxReverbEffect::defer_echo_time(
1860     float flEchoTime)
1861 {
1862     eax_d_.flEchoTime = flEchoTime;
1863     eax_dirty_flags_.flEchoTime = (eax_.flEchoTime != eax_d_.flEchoTime);
1864 }
1865
1866 void EaxReverbEffect::defer_echo_depth(
1867     float flEchoDepth)
1868 {
1869     eax_d_.flEchoDepth = flEchoDepth;
1870     eax_dirty_flags_.flEchoDepth = (eax_.flEchoDepth != eax_d_.flEchoDepth);
1871 }
1872
1873 void EaxReverbEffect::defer_modulation_time(
1874     float flModulationTime)
1875 {
1876     eax_d_.flModulationTime = flModulationTime;
1877     eax_dirty_flags_.flModulationTime = (eax_.flModulationTime != eax_d_.flModulationTime);
1878 }
1879
1880 void EaxReverbEffect::defer_modulation_depth(
1881     float flModulationDepth)
1882 {
1883     eax_d_.flModulationDepth = flModulationDepth;
1884     eax_dirty_flags_.flModulationDepth = (eax_.flModulationDepth != eax_d_.flModulationDepth);
1885 }
1886
1887 void EaxReverbEffect::defer_air_absorbtion_hf(
1888     float flAirAbsorptionHF)
1889 {
1890     eax_d_.flAirAbsorptionHF = flAirAbsorptionHF;
1891     eax_dirty_flags_.flAirAbsorptionHF = (eax_.flAirAbsorptionHF != eax_d_.flAirAbsorptionHF);
1892 }
1893
1894 void EaxReverbEffect::defer_hf_reference(
1895     float flHFReference)
1896 {
1897     eax_d_.flHFReference = flHFReference;
1898     eax_dirty_flags_.flHFReference = (eax_.flHFReference != eax_d_.flHFReference);
1899 }
1900
1901 void EaxReverbEffect::defer_lf_reference(
1902     float flLFReference)
1903 {
1904     eax_d_.flLFReference = flLFReference;
1905     eax_dirty_flags_.flLFReference = (eax_.flLFReference != eax_d_.flLFReference);
1906 }
1907
1908 void EaxReverbEffect::defer_room_rolloff_factor(
1909     float flRoomRolloffFactor)
1910 {
1911     eax_d_.flRoomRolloffFactor = flRoomRolloffFactor;
1912     eax_dirty_flags_.flRoomRolloffFactor = (eax_.flRoomRolloffFactor != eax_d_.flRoomRolloffFactor);
1913 }
1914
1915 void EaxReverbEffect::defer_flags(
1916     unsigned long ulFlags)
1917 {
1918     eax_d_.ulFlags = ulFlags;
1919     eax_dirty_flags_.ulFlags = (eax_.ulFlags != eax_d_.ulFlags);
1920 }
1921
1922 void EaxReverbEffect::defer_all(
1923     const EAX20LISTENERPROPERTIES& listener)
1924 {
1925     defer_room(listener.lRoom);
1926     defer_room_hf(listener.lRoomHF);
1927     defer_room_rolloff_factor(listener.flRoomRolloffFactor);
1928     defer_decay_time(listener.flDecayTime);
1929     defer_decay_hf_ratio(listener.flDecayHFRatio);
1930     defer_reflections(listener.lReflections);
1931     defer_reflections_delay(listener.flReflectionsDelay);
1932     defer_reverb(listener.lReverb);
1933     defer_reverb_delay(listener.flReverbDelay);
1934     defer_environment(listener.dwEnvironment);
1935     defer_environment_size(listener.flEnvironmentSize);
1936     defer_environment_diffusion(listener.flEnvironmentDiffusion);
1937     defer_air_absorbtion_hf(listener.flAirAbsorptionHF);
1938     defer_flags(listener.dwFlags);
1939 }
1940
1941 void EaxReverbEffect::defer_all(
1942     const EAXREVERBPROPERTIES& lReverb)
1943 {
1944     defer_environment(lReverb.ulEnvironment);
1945     defer_environment_size(lReverb.flEnvironmentSize);
1946     defer_environment_diffusion(lReverb.flEnvironmentDiffusion);
1947     defer_room(lReverb.lRoom);
1948     defer_room_hf(lReverb.lRoomHF);
1949     defer_room_lf(lReverb.lRoomLF);
1950     defer_decay_time(lReverb.flDecayTime);
1951     defer_decay_hf_ratio(lReverb.flDecayHFRatio);
1952     defer_decay_lf_ratio(lReverb.flDecayLFRatio);
1953     defer_reflections(lReverb.lReflections);
1954     defer_reflections_delay(lReverb.flReflectionsDelay);
1955     defer_reflections_pan(lReverb.vReflectionsPan);
1956     defer_reverb(lReverb.lReverb);
1957     defer_reverb_delay(lReverb.flReverbDelay);
1958     defer_reverb_pan(lReverb.vReverbPan);
1959     defer_echo_time(lReverb.flEchoTime);
1960     defer_echo_depth(lReverb.flEchoDepth);
1961     defer_modulation_time(lReverb.flModulationTime);
1962     defer_modulation_depth(lReverb.flModulationDepth);
1963     defer_air_absorbtion_hf(lReverb.flAirAbsorptionHF);
1964     defer_hf_reference(lReverb.flHFReference);
1965     defer_lf_reference(lReverb.flLFReference);
1966     defer_room_rolloff_factor(lReverb.flRoomRolloffFactor);
1967     defer_flags(lReverb.ulFlags);
1968 }
1969
1970 void EaxReverbEffect::defer_environment(
1971     const EaxEaxCall& eax_call)
1972 {
1973     const auto& ulEnvironment =
1974         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::ulEnvironment)>();
1975
1976     validate_environment(ulEnvironment, eax_call.get_version(), true);
1977
1978     if (eax_d_.ulEnvironment == ulEnvironment)
1979     {
1980         return;
1981     }
1982
1983     const auto& reverb_preset = EAXREVERB_PRESETS[ulEnvironment];
1984
1985     defer_all(reverb_preset);
1986 }
1987
1988 void EaxReverbEffect::defer_environment_size(
1989     const EaxEaxCall& eax_call)
1990 {
1991     const auto& flEnvironmentSize =
1992         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flEnvironmentSize)>();
1993
1994     validate_environment_size(flEnvironmentSize);
1995
1996     if (eax_d_.flEnvironmentSize == flEnvironmentSize)
1997     {
1998         return;
1999     }
2000
2001     const auto scale = flEnvironmentSize / eax_d_.flEnvironmentSize;
2002
2003     defer_environment_size(flEnvironmentSize);
2004
2005     if ((eax_d_.ulFlags & EAXREVERBFLAGS_DECAYTIMESCALE) != 0)
2006     {
2007         const auto flDecayTime = clamp(
2008             scale * eax_d_.flDecayTime,
2009             EAXREVERB_MINDECAYTIME,
2010             EAXREVERB_MAXDECAYTIME);
2011
2012         defer_decay_time(flDecayTime);
2013     }
2014
2015     if ((eax_d_.ulFlags & EAXREVERBFLAGS_REFLECTIONSSCALE) != 0)
2016     {
2017         if ((eax_d_.ulFlags & EAXREVERBFLAGS_REFLECTIONSDELAYSCALE) != 0)
2018         {
2019             const auto lReflections = clamp(
2020                 eax_d_.lReflections - static_cast<long>(gain_to_level_mb(scale)),
2021                 EAXREVERB_MINREFLECTIONS,
2022                 EAXREVERB_MAXREFLECTIONS);
2023
2024             defer_reflections(lReflections);
2025         }
2026     }
2027
2028     if ((eax_d_.ulFlags & EAXREVERBFLAGS_REFLECTIONSDELAYSCALE) != 0)
2029     {
2030         const auto flReflectionsDelay = clamp(
2031             eax_d_.flReflectionsDelay * scale,
2032             EAXREVERB_MINREFLECTIONSDELAY,
2033             EAXREVERB_MAXREFLECTIONSDELAY);
2034
2035         defer_reflections_delay(flReflectionsDelay);
2036     }
2037
2038     if ((eax_d_.ulFlags & EAXREVERBFLAGS_REVERBSCALE) != 0)
2039     {
2040         const auto log_scalar = ((eax_d_.ulFlags & EAXREVERBFLAGS_DECAYTIMESCALE) != 0) ? 2'000.0F : 3'000.0F;
2041
2042         const auto lReverb = clamp(
2043             eax_d_.lReverb - static_cast<long>(std::log10(scale) * log_scalar),
2044             EAXREVERB_MINREVERB,
2045             EAXREVERB_MAXREVERB);
2046
2047         defer_reverb(lReverb);
2048     }
2049
2050     if ((eax_d_.ulFlags & EAXREVERBFLAGS_REVERBDELAYSCALE) != 0)
2051     {
2052         const auto flReverbDelay = clamp(
2053             scale * eax_d_.flReverbDelay,
2054             EAXREVERB_MINREVERBDELAY,
2055             EAXREVERB_MAXREVERBDELAY);
2056
2057         defer_reverb_delay(flReverbDelay);
2058     }
2059
2060     if ((eax_d_.ulFlags & EAXREVERBFLAGS_ECHOTIMESCALE) != 0)
2061     {
2062         const auto flEchoTime = clamp(
2063             eax_d_.flEchoTime * scale,
2064             EAXREVERB_MINECHOTIME,
2065             EAXREVERB_MAXECHOTIME);
2066
2067         defer_echo_time(flEchoTime);
2068     }
2069
2070     if ((eax_d_.ulFlags & EAXREVERBFLAGS_MODULATIONTIMESCALE) != 0)
2071     {
2072         const auto flModulationTime = clamp(
2073             scale * eax_d_.flModulationTime,
2074             EAXREVERB_MINMODULATIONTIME,
2075             EAXREVERB_MAXMODULATIONTIME);
2076
2077         defer_modulation_time(flModulationTime);
2078     }
2079 }
2080
2081 void EaxReverbEffect::defer_environment_diffusion(
2082     const EaxEaxCall& eax_call)
2083 {
2084     const auto& flEnvironmentDiffusion =
2085         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flEnvironmentDiffusion)>();
2086
2087     validate_environment_diffusion(flEnvironmentDiffusion);
2088     defer_environment_diffusion(flEnvironmentDiffusion);
2089 }
2090
2091 void EaxReverbEffect::defer_room(
2092     const EaxEaxCall& eax_call)
2093 {
2094     const auto& lRoom =
2095         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::lRoom)>();
2096
2097     validate_room(lRoom);
2098     defer_room(lRoom);
2099 }
2100
2101 void EaxReverbEffect::defer_room_hf(
2102     const EaxEaxCall& eax_call)
2103 {
2104     const auto& lRoomHF =
2105         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::lRoomHF)>();
2106
2107     validate_room_hf(lRoomHF);
2108     defer_room_hf(lRoomHF);
2109 }
2110
2111 void EaxReverbEffect::defer_room_lf(
2112     const EaxEaxCall& eax_call)
2113 {
2114     const auto& lRoomLF =
2115         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::lRoomLF)>();
2116
2117     validate_room_lf(lRoomLF);
2118     defer_room_lf(lRoomLF);
2119 }
2120
2121 void EaxReverbEffect::defer_decay_time(
2122     const EaxEaxCall& eax_call)
2123 {
2124     const auto& flDecayTime =
2125         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flDecayTime)>();
2126
2127     validate_decay_time(flDecayTime);
2128     defer_decay_time(flDecayTime);
2129 }
2130
2131 void EaxReverbEffect::defer_decay_hf_ratio(
2132     const EaxEaxCall& eax_call)
2133 {
2134     const auto& flDecayHFRatio =
2135         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flDecayHFRatio)>();
2136
2137     validate_decay_hf_ratio(flDecayHFRatio);
2138     defer_decay_hf_ratio(flDecayHFRatio);
2139 }
2140
2141 void EaxReverbEffect::defer_decay_lf_ratio(
2142     const EaxEaxCall& eax_call)
2143 {
2144     const auto& flDecayLFRatio =
2145         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flDecayLFRatio)>();
2146
2147     validate_decay_lf_ratio(flDecayLFRatio);
2148     defer_decay_lf_ratio(flDecayLFRatio);
2149 }
2150
2151 void EaxReverbEffect::defer_reflections(
2152     const EaxEaxCall& eax_call)
2153 {
2154     const auto& lReflections =
2155         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::lReflections)>();
2156
2157     validate_reflections(lReflections);
2158     defer_reflections(lReflections);
2159 }
2160
2161 void EaxReverbEffect::defer_reflections_delay(
2162     const EaxEaxCall& eax_call)
2163 {
2164     const auto& flReflectionsDelay =
2165         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flReflectionsDelay)>();
2166
2167     validate_reflections_delay(flReflectionsDelay);
2168     defer_reflections_delay(flReflectionsDelay);
2169 }
2170
2171 void EaxReverbEffect::defer_reflections_pan(
2172     const EaxEaxCall& eax_call)
2173 {
2174     const auto& vReflectionsPan =
2175         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::vReflectionsPan)>();
2176
2177     validate_reflections_pan(vReflectionsPan);
2178     defer_reflections_pan(vReflectionsPan);
2179 }
2180
2181 void EaxReverbEffect::defer_reverb(
2182     const EaxEaxCall& eax_call)
2183 {
2184     const auto& lReverb =
2185         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::lReverb)>();
2186
2187     validate_reverb(lReverb);
2188     defer_reverb(lReverb);
2189 }
2190
2191 void EaxReverbEffect::defer_reverb_delay(
2192     const EaxEaxCall& eax_call)
2193 {
2194     const auto& flReverbDelay =
2195         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flReverbDelay)>();
2196
2197     validate_reverb_delay(flReverbDelay);
2198     defer_reverb_delay(flReverbDelay);
2199 }
2200
2201 void EaxReverbEffect::defer_reverb_pan(
2202     const EaxEaxCall& eax_call)
2203 {
2204     const auto& vReverbPan =
2205         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::vReverbPan)>();
2206
2207     validate_reverb_pan(vReverbPan);
2208     defer_reverb_pan(vReverbPan);
2209 }
2210
2211 void EaxReverbEffect::defer_echo_time(
2212     const EaxEaxCall& eax_call)
2213 {
2214     const auto& flEchoTime =
2215         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flEchoTime)>();
2216
2217     validate_echo_time(flEchoTime);
2218     defer_echo_time(flEchoTime);
2219 }
2220
2221 void EaxReverbEffect::defer_echo_depth(
2222     const EaxEaxCall& eax_call)
2223 {
2224     const auto& flEchoDepth =
2225         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flEchoDepth)>();
2226
2227     validate_echo_depth(flEchoDepth);
2228     defer_echo_depth(flEchoDepth);
2229 }
2230
2231 void EaxReverbEffect::defer_modulation_time(
2232     const EaxEaxCall& eax_call)
2233 {
2234     const auto& flModulationTime =
2235         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flModulationTime)>();
2236
2237     validate_modulation_time(flModulationTime);
2238     defer_modulation_time(flModulationTime);
2239 }
2240
2241 void EaxReverbEffect::defer_modulation_depth(
2242     const EaxEaxCall& eax_call)
2243 {
2244     const auto& flModulationDepth =
2245         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flModulationDepth)>();
2246
2247     validate_modulation_depth(flModulationDepth);
2248     defer_modulation_depth(flModulationDepth);
2249 }
2250
2251 void EaxReverbEffect::defer_air_absorbtion_hf(
2252     const EaxEaxCall& eax_call)
2253 {
2254     const auto& air_absorbtion_hf =
2255         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flAirAbsorptionHF)>();
2256
2257     validate_air_absorbtion_hf(air_absorbtion_hf);
2258     defer_air_absorbtion_hf(air_absorbtion_hf);
2259 }
2260
2261 void EaxReverbEffect::defer_hf_reference(
2262     const EaxEaxCall& eax_call)
2263 {
2264     const auto& flHFReference =
2265         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flHFReference)>();
2266
2267     validate_hf_reference(flHFReference);
2268     defer_hf_reference(flHFReference);
2269 }
2270
2271 void EaxReverbEffect::defer_lf_reference(
2272     const EaxEaxCall& eax_call)
2273 {
2274     const auto& flLFReference =
2275         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flLFReference)>();
2276
2277     validate_lf_reference(flLFReference);
2278     defer_lf_reference(flLFReference);
2279 }
2280
2281 void EaxReverbEffect::defer_room_rolloff_factor(
2282     const EaxEaxCall& eax_call)
2283 {
2284     const auto& flRoomRolloffFactor =
2285         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::flRoomRolloffFactor)>();
2286
2287     validate_room_rolloff_factor(flRoomRolloffFactor);
2288     defer_room_rolloff_factor(flRoomRolloffFactor);
2289 }
2290
2291 void EaxReverbEffect::defer_flags(
2292     const EaxEaxCall& eax_call)
2293 {
2294     const auto& ulFlags =
2295         eax_call.get_value<EaxReverbEffectException, const decltype(EAXREVERBPROPERTIES::ulFlags)>();
2296
2297     validate_flags(ulFlags);
2298     defer_flags(ulFlags);
2299 }
2300
2301 void EaxReverbEffect::defer_all(
2302     const EaxEaxCall& eax_call)
2303 {
2304     const auto eax_version = eax_call.get_version();
2305
2306     if (eax_version == 2)
2307     {
2308         const auto& listener =
2309             eax_call.get_value<EaxReverbEffectException, const EAX20LISTENERPROPERTIES>();
2310
2311         validate_all(listener, eax_version);
2312         defer_all(listener);
2313     }
2314     else
2315     {
2316         const auto& reverb_all =
2317             eax_call.get_value<EaxReverbEffectException, const EAXREVERBPROPERTIES>();
2318
2319         validate_all(reverb_all, eax_version);
2320         defer_all(reverb_all);
2321     }
2322 }
2323
2324 bool EaxReverbEffect::v1_set_environment(const EaxEaxCall& eax_call)
2325 {
2326     const auto environment = eax_call.get_value<EaxReverbEffectException, const decltype(EAX_REVERBPROPERTIES::environment)>();
2327     v1_validate_environment(environment);
2328
2329     if (eax1_.environment == environment)
2330         return false;
2331
2332     eax1_.environment = environment;
2333     v1_set_efx();
2334     return true;
2335 }
2336
2337 bool EaxReverbEffect::v1_set_volume(const EaxEaxCall& eax_call)
2338 {
2339     const auto volume = eax_call.get_value<EaxReverbEffectException, const decltype(EAX_REVERBPROPERTIES::fVolume)>();
2340     v1_validate_volume(volume);
2341
2342     if (eax1_.fVolume == volume)
2343         return false;
2344
2345     eax1_.fVolume = volume;
2346     v1_set_efx();
2347     return true;
2348 }
2349
2350 bool EaxReverbEffect::v1_set_decay_time(const EaxEaxCall& eax_call)
2351 {
2352     const auto decay_time = eax_call.get_value<EaxReverbEffectException, const decltype(EAX_REVERBPROPERTIES::fDecayTime_sec)>();
2353     v1_validate_decay_time(decay_time);
2354
2355     if (eax1_.fDecayTime_sec == decay_time)
2356         return false;
2357
2358     eax1_.fDecayTime_sec = decay_time;
2359     v1_set_efx();
2360     return true;
2361 }
2362
2363 bool EaxReverbEffect::v1_set_damping(const EaxEaxCall& eax_call)
2364 {
2365     const auto damping = eax_call.get_value<EaxReverbEffectException, const decltype(EAX_REVERBPROPERTIES::fDamping)>();
2366     v1_validate_damping(damping);
2367
2368     if (eax1_.fDamping == damping)
2369         return false;
2370
2371     eax1_.fDamping = damping;
2372     v1_set_efx();
2373     return true;
2374 }
2375
2376 bool EaxReverbEffect::v1_set_all(const EaxEaxCall& eax_call)
2377 {
2378     const auto& all = eax_call.get_value<EaxReverbEffectException, const EAX_REVERBPROPERTIES>();
2379     v1_validate_all(all);
2380
2381     if (eax1_ == all)
2382         return false;
2383
2384     eax1_.environment = all.environment;
2385     eax1_.fVolume = all.fVolume;
2386     eax1_.fDecayTime_sec = all.fDecayTime_sec;
2387     eax1_.fDamping = all.fDamping;
2388     v1_set_efx();
2389     return true;
2390 }
2391
2392 bool EaxReverbEffect::v1_set(const EaxEaxCall& eax_call)
2393 {
2394     switch (eax_call.get_property_id())
2395     {
2396         case DSPROPERTY_EAX_ALL: return v1_set_all(eax_call);
2397         case DSPROPERTY_EAX_ENVIRONMENT: return v1_set_environment(eax_call);
2398         case DSPROPERTY_EAX_VOLUME: return v1_set_volume(eax_call);
2399         case DSPROPERTY_EAX_DECAYTIME: return v1_set_decay_time(eax_call);
2400         case DSPROPERTY_EAX_DAMPING: return v1_set_damping(eax_call);
2401         default: eax_fail("Unsupported property id.");
2402     }
2403 }
2404
2405 // [[nodiscard]]
2406 bool EaxReverbEffect::apply_deferred()
2407 {
2408     if (eax_dirty_flags_ == EaxReverbEffectDirtyFlags{})
2409     {
2410         return false;
2411     }
2412
2413     eax_ = eax_d_;
2414
2415     if (eax_dirty_flags_.ulEnvironment)
2416     {
2417     }
2418
2419     if (eax_dirty_flags_.flEnvironmentSize)
2420     {
2421         set_efx_density_from_environment_size();
2422     }
2423
2424     if (eax_dirty_flags_.flEnvironmentDiffusion)
2425     {
2426         set_efx_diffusion();
2427     }
2428
2429     if (eax_dirty_flags_.lRoom)
2430     {
2431         set_efx_gain();
2432     }
2433
2434     if (eax_dirty_flags_.lRoomHF)
2435     {
2436         set_efx_gain_hf();
2437     }
2438
2439     if (eax_dirty_flags_.lRoomLF)
2440     {
2441         set_efx_gain_lf();
2442     }
2443
2444     if (eax_dirty_flags_.flDecayTime)
2445     {
2446         set_efx_decay_time();
2447     }
2448
2449     if (eax_dirty_flags_.flDecayHFRatio)
2450     {
2451         set_efx_decay_hf_ratio();
2452     }
2453
2454     if (eax_dirty_flags_.flDecayLFRatio)
2455     {
2456         set_efx_decay_lf_ratio();
2457     }
2458
2459     if (eax_dirty_flags_.lReflections)
2460     {
2461         set_efx_reflections_gain();
2462     }
2463
2464     if (eax_dirty_flags_.flReflectionsDelay)
2465     {
2466         set_efx_reflections_delay();
2467     }
2468
2469     if (eax_dirty_flags_.vReflectionsPan)
2470     {
2471         set_efx_reflections_pan();
2472     }
2473
2474     if (eax_dirty_flags_.lReverb)
2475     {
2476         set_efx_late_reverb_gain();
2477     }
2478
2479     if (eax_dirty_flags_.flReverbDelay)
2480     {
2481         set_efx_late_reverb_delay();
2482     }
2483
2484     if (eax_dirty_flags_.vReverbPan)
2485     {
2486         set_efx_late_reverb_pan();
2487     }
2488
2489     if (eax_dirty_flags_.flEchoTime)
2490     {
2491         set_efx_echo_time();
2492     }
2493
2494     if (eax_dirty_flags_.flEchoDepth)
2495     {
2496         set_efx_echo_depth();
2497     }
2498
2499     if (eax_dirty_flags_.flModulationTime)
2500     {
2501         set_efx_modulation_time();
2502     }
2503
2504     if (eax_dirty_flags_.flModulationDepth)
2505     {
2506         set_efx_modulation_depth();
2507     }
2508
2509     if (eax_dirty_flags_.flAirAbsorptionHF)
2510     {
2511         set_efx_air_absorption_gain_hf();
2512     }
2513
2514     if (eax_dirty_flags_.flHFReference)
2515     {
2516         set_efx_hf_reference();
2517     }
2518
2519     if (eax_dirty_flags_.flLFReference)
2520     {
2521         set_efx_lf_reference();
2522     }
2523
2524     if (eax_dirty_flags_.flRoomRolloffFactor)
2525     {
2526         set_efx_room_rolloff_factor();
2527     }
2528
2529     if (eax_dirty_flags_.ulFlags)
2530     {
2531         set_efx_flags();
2532     }
2533
2534     eax_dirty_flags_ = EaxReverbEffectDirtyFlags{};
2535
2536     return true;
2537 }
2538
2539 // [[nodiscard]]
2540 bool EaxReverbEffect::set(
2541     const EaxEaxCall& eax_call)
2542 {
2543     if (eax_call.get_version() == 1)
2544         return v1_set(eax_call);
2545
2546     switch (eax_call.get_property_id())
2547     {
2548         case EAXREVERB_NONE:
2549             break;
2550
2551         case EAXREVERB_ALLPARAMETERS:
2552             defer_all(eax_call);
2553             break;
2554
2555         case EAXREVERB_ENVIRONMENT:
2556             defer_environment(eax_call);
2557             break;
2558
2559         case EAXREVERB_ENVIRONMENTSIZE:
2560             defer_environment_size(eax_call);
2561             break;
2562
2563         case EAXREVERB_ENVIRONMENTDIFFUSION:
2564             defer_environment_diffusion(eax_call);
2565             break;
2566
2567         case EAXREVERB_ROOM:
2568             defer_room(eax_call);
2569             break;
2570
2571         case EAXREVERB_ROOMHF:
2572             defer_room_hf(eax_call);
2573             break;
2574
2575         case EAXREVERB_ROOMLF:
2576             defer_room_lf(eax_call);
2577             break;
2578
2579         case EAXREVERB_DECAYTIME:
2580             defer_decay_time(eax_call);
2581             break;
2582
2583         case EAXREVERB_DECAYHFRATIO:
2584             defer_decay_hf_ratio(eax_call);
2585             break;
2586
2587         case EAXREVERB_DECAYLFRATIO:
2588             defer_decay_lf_ratio(eax_call);
2589             break;
2590
2591         case EAXREVERB_REFLECTIONS:
2592             defer_reflections(eax_call);
2593             break;
2594
2595         case EAXREVERB_REFLECTIONSDELAY:
2596             defer_reflections_delay(eax_call);
2597             break;
2598
2599         case EAXREVERB_REFLECTIONSPAN:
2600             defer_reflections_pan(eax_call);
2601             break;
2602
2603         case EAXREVERB_REVERB:
2604             defer_reverb(eax_call);
2605             break;
2606
2607         case EAXREVERB_REVERBDELAY:
2608             defer_reverb_delay(eax_call);
2609             break;
2610
2611         case EAXREVERB_REVERBPAN:
2612             defer_reverb_pan(eax_call);
2613             break;
2614
2615         case EAXREVERB_ECHOTIME:
2616             defer_echo_time(eax_call);
2617             break;
2618
2619         case EAXREVERB_ECHODEPTH:
2620             defer_echo_depth(eax_call);
2621             break;
2622
2623         case EAXREVERB_MODULATIONTIME:
2624             defer_modulation_time(eax_call);
2625             break;
2626
2627         case EAXREVERB_MODULATIONDEPTH:
2628             defer_modulation_depth(eax_call);
2629             break;
2630
2631         case EAXREVERB_AIRABSORPTIONHF:
2632             defer_air_absorbtion_hf(eax_call);
2633             break;
2634
2635         case EAXREVERB_HFREFERENCE:
2636             defer_hf_reference(eax_call);
2637             break;
2638
2639         case EAXREVERB_LFREFERENCE:
2640             defer_lf_reference(eax_call);
2641             break;
2642
2643         case EAXREVERB_ROOMROLLOFFFACTOR:
2644             defer_room_rolloff_factor(eax_call);
2645             break;
2646
2647         case EAXREVERB_FLAGS:
2648             defer_flags(eax_call);
2649             break;
2650
2651         default:
2652             eax_fail("Unsupported property id.");
2653     }
2654
2655     if (!eax_call.is_deferred())
2656     {
2657         return apply_deferred();
2658     }
2659
2660     return false;
2661 }
2662
2663 const EFXEAXREVERBPROPERTIES eax_efx_reverb_presets[EAX1_ENVIRONMENT_COUNT] =
2664 {
2665     EFX_REVERB_PRESET_GENERIC,
2666     EFX_REVERB_PRESET_PADDEDCELL,
2667     EFX_REVERB_PRESET_ROOM,
2668     EFX_REVERB_PRESET_BATHROOM,
2669     EFX_REVERB_PRESET_LIVINGROOM,
2670     EFX_REVERB_PRESET_STONEROOM,
2671     EFX_REVERB_PRESET_AUDITORIUM,
2672     EFX_REVERB_PRESET_CONCERTHALL,
2673     EFX_REVERB_PRESET_CAVE,
2674     EFX_REVERB_PRESET_ARENA,
2675     EFX_REVERB_PRESET_HANGAR,
2676     EFX_REVERB_PRESET_CARPETEDHALLWAY,
2677     EFX_REVERB_PRESET_HALLWAY,
2678     EFX_REVERB_PRESET_STONECORRIDOR,
2679     EFX_REVERB_PRESET_ALLEY,
2680     EFX_REVERB_PRESET_FOREST,
2681     EFX_REVERB_PRESET_CITY,
2682     EFX_REVERB_PRESET_MOUNTAINS,
2683     EFX_REVERB_PRESET_QUARRY,
2684     EFX_REVERB_PRESET_PLAIN,
2685     EFX_REVERB_PRESET_PARKINGLOT,
2686     EFX_REVERB_PRESET_SEWERPIPE,
2687     EFX_REVERB_PRESET_UNDERWATER,
2688     EFX_REVERB_PRESET_DRUGGED,
2689     EFX_REVERB_PRESET_DIZZY,
2690     EFX_REVERB_PRESET_PSYCHOTIC,
2691 }; // EFXEAXREVERBPROPERTIES
2692
2693 } // namespace
2694
2695 EaxEffectUPtr eax_create_eax_reverb_effect()
2696 {
2697     return std::make_unique<EaxReverbEffect>();
2698 }
2699
2700 #endif // ALSOFT_EAX