al/effects/equalizer.cpp

   1
   2 #include "config.h"
   3
   4 #include "AL/al.h"
   5 #include "AL/efx.h"
   6
   7 #include "alc/effects/base.h"
   8 #include "effects.h"
   9
  10 #ifdef ALSOFT_EAX
  11 #include "alnumeric.h"
  12
  13 #include "al/eax_exception.h"
  14 #include "al/eax_utils.h"
  15 #endif // ALSOFT_EAX
  16
  17
  18 namespace {
  19
  20 void Equalizer_setParami(EffectProps*, ALenum param, int)
  21 { throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param}; }
  22 void Equalizer_setParamiv(EffectProps*, ALenum param, const int*)
  23 {
  24     throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x",
  25         param};
  26 }
  27 void Equalizer_setParamf(EffectProps *props, ALenum param, float val)
  28 {
  29     switch(param)
  30     {
  31     case AL_EQUALIZER_LOW_GAIN:
  32         if(!(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN))
  33             throw effect_exception{AL_INVALID_VALUE, "Equalizer low-band gain out of range"};
  34         props->Equalizer.LowGain = val;
  35         break;
  36
  37     case AL_EQUALIZER_LOW_CUTOFF:
  38         if(!(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF))
  39             throw effect_exception{AL_INVALID_VALUE, "Equalizer low-band cutoff out of range"};
  40         props->Equalizer.LowCutoff = val;
  41         break;
  42
  43     case AL_EQUALIZER_MID1_GAIN:
  44         if(!(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN))
  45             throw effect_exception{AL_INVALID_VALUE, "Equalizer mid1-band gain out of range"};
  46         props->Equalizer.Mid1Gain = val;
  47         break;
  48
  49     case AL_EQUALIZER_MID1_CENTER:
  50         if(!(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER))
  51             throw effect_exception{AL_INVALID_VALUE, "Equalizer mid1-band center out of range"};
  52         props->Equalizer.Mid1Center = val;
  53         break;
  54
  55     case AL_EQUALIZER_MID1_WIDTH:
  56         if(!(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH))
  57             throw effect_exception{AL_INVALID_VALUE, "Equalizer mid1-band width out of range"};
  58         props->Equalizer.Mid1Width = val;
  59         break;
  60
  61     case AL_EQUALIZER_MID2_GAIN:
  62         if(!(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN))
  63             throw effect_exception{AL_INVALID_VALUE, "Equalizer mid2-band gain out of range"};
  64         props->Equalizer.Mid2Gain = val;
  65         break;
  66
  67     case AL_EQUALIZER_MID2_CENTER:
  68         if(!(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER))
  69             throw effect_exception{AL_INVALID_VALUE, "Equalizer mid2-band center out of range"};
  70         props->Equalizer.Mid2Center = val;
  71         break;
  72
  73     case AL_EQUALIZER_MID2_WIDTH:
  74         if(!(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH))
  75             throw effect_exception{AL_INVALID_VALUE, "Equalizer mid2-band width out of range"};
  76         props->Equalizer.Mid2Width = val;
  77         break;
  78
  79     case AL_EQUALIZER_HIGH_GAIN:
  80         if(!(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN))
  81             throw effect_exception{AL_INVALID_VALUE, "Equalizer high-band gain out of range"};
  82         props->Equalizer.HighGain = val;
  83         break;
  84
  85     case AL_EQUALIZER_HIGH_CUTOFF:
  86         if(!(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF))
  87             throw effect_exception{AL_INVALID_VALUE, "Equalizer high-band cutoff out of range"};
  88         props->Equalizer.HighCutoff = val;
  89         break;
  90
  91     default:
  92         throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param};
  93     }
  94 }
  95 void Equalizer_setParamfv(EffectProps *props, ALenum param, const float *vals)
  96 { Equalizer_setParamf(props, param, vals[0]); }
  97
  98 void Equalizer_getParami(const EffectProps*, ALenum param, int*)
  99 { throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer property 0x%04x", param}; }
 100 void Equalizer_getParamiv(const EffectProps*, ALenum param, int*)
 101 {
 102     throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer integer-vector property 0x%04x",
 103         param};
 104 }
 105 void Equalizer_getParamf(const EffectProps *props, ALenum param, float *val)
 106 {
 107     switch(param)
 108     {
 109     case AL_EQUALIZER_LOW_GAIN:
 110         *val = props->Equalizer.LowGain;
 111         break;
 112
 113     case AL_EQUALIZER_LOW_CUTOFF:
 114         *val = props->Equalizer.LowCutoff;
 115         break;
 116
 117     case AL_EQUALIZER_MID1_GAIN:
 118         *val = props->Equalizer.Mid1Gain;
 119         break;
 120
 121     case AL_EQUALIZER_MID1_CENTER:
 122         *val = props->Equalizer.Mid1Center;
 123         break;
 124
 125     case AL_EQUALIZER_MID1_WIDTH:
 126         *val = props->Equalizer.Mid1Width;
 127         break;
 128
 129     case AL_EQUALIZER_MID2_GAIN:
 130         *val = props->Equalizer.Mid2Gain;
 131         break;
 132
 133     case AL_EQUALIZER_MID2_CENTER:
 134         *val = props->Equalizer.Mid2Center;
 135         break;
 136
 137     case AL_EQUALIZER_MID2_WIDTH:
 138         *val = props->Equalizer.Mid2Width;
 139         break;
 140
 141     case AL_EQUALIZER_HIGH_GAIN:
 142         *val = props->Equalizer.HighGain;
 143         break;
 144
 145     case AL_EQUALIZER_HIGH_CUTOFF:
 146         *val = props->Equalizer.HighCutoff;
 147         break;
 148
 149     default:
 150         throw effect_exception{AL_INVALID_ENUM, "Invalid equalizer float property 0x%04x", param};
 151     }
 152 }
 153 void Equalizer_getParamfv(const EffectProps *props, ALenum param, float *vals)
 154 { Equalizer_getParamf(props, param, vals); }
 155
 156 EffectProps genDefaultProps() noexcept
 157 {
 158     EffectProps props{};
 159     props.Equalizer.LowCutoff = AL_EQUALIZER_DEFAULT_LOW_CUTOFF;
 160     props.Equalizer.LowGain = AL_EQUALIZER_DEFAULT_LOW_GAIN;
 161     props.Equalizer.Mid1Center = AL_EQUALIZER_DEFAULT_MID1_CENTER;
 162     props.Equalizer.Mid1Gain = AL_EQUALIZER_DEFAULT_MID1_GAIN;
 163     props.Equalizer.Mid1Width = AL_EQUALIZER_DEFAULT_MID1_WIDTH;
 164     props.Equalizer.Mid2Center = AL_EQUALIZER_DEFAULT_MID2_CENTER;
 165     props.Equalizer.Mid2Gain = AL_EQUALIZER_DEFAULT_MID2_GAIN;
 166     props.Equalizer.Mid2Width = AL_EQUALIZER_DEFAULT_MID2_WIDTH;
 167     props.Equalizer.HighCutoff = AL_EQUALIZER_DEFAULT_HIGH_CUTOFF;
 168     props.Equalizer.HighGain = AL_EQUALIZER_DEFAULT_HIGH_GAIN;
 169     return props;
 170 }
 171
 172 } // namespace
 173
 174 DEFINE_ALEFFECT_VTABLE(Equalizer);
 175
 176 const EffectProps EqualizerEffectProps{genDefaultProps()};
 177
 178 #ifdef ALSOFT_EAX
 179 namespace {
 180
 181 using EaxEqualizerEffectDirtyFlagsValue = std::uint_least16_t;
 182
 183 struct EaxEqualizerEffectDirtyFlags
 184 {
 185     using EaxIsBitFieldStruct = bool;
 186
 187     EaxEqualizerEffectDirtyFlagsValue lLowGain : 1;
 188     EaxEqualizerEffectDirtyFlagsValue flLowCutOff : 1;
 189     EaxEqualizerEffectDirtyFlagsValue lMid1Gain : 1;
 190     EaxEqualizerEffectDirtyFlagsValue flMid1Center : 1;
 191     EaxEqualizerEffectDirtyFlagsValue flMid1Width : 1;
 192     EaxEqualizerEffectDirtyFlagsValue lMid2Gain : 1;
 193     EaxEqualizerEffectDirtyFlagsValue flMid2Center : 1;
 194     EaxEqualizerEffectDirtyFlagsValue flMid2Width : 1;
 195     EaxEqualizerEffectDirtyFlagsValue lHighGain : 1;
 196     EaxEqualizerEffectDirtyFlagsValue flHighCutOff : 1;
 197 }; // EaxEqualizerEffectDirtyFlags
 198
 199
 200 class EaxEqualizerEffect final :
 201     public EaxEffect
 202 {
 203 public:
 204     EaxEqualizerEffect();
 205
 206
 207     // [[nodiscard]]
 208     bool dispatch(
 209         const EaxEaxCall& eax_call) override;
 210
 211
 212 private:
 213     EAXEQUALIZERPROPERTIES eax_{};
 214     EAXEQUALIZERPROPERTIES eax_d_{};
 215     EaxEqualizerEffectDirtyFlags eax_dirty_flags_{};
 216
 217
 218     void set_eax_defaults();
 219
 220
 221     void set_efx_low_gain();
 222
 223     void set_efx_low_cutoff();
 224
 225     void set_efx_mid1_gain();
 226
 227     void set_efx_mid1_center();
 228
 229     void set_efx_mid1_width();
 230
 231     void set_efx_mid2_gain();
 232
 233     void set_efx_mid2_center();
 234
 235     void set_efx_mid2_width();
 236
 237     void set_efx_high_gain();
 238
 239     void set_efx_high_cutoff();
 240
 241     void set_efx_defaults();
 242
 243
 244     // [[nodiscard]]
 245     bool get(
 246         const EaxEaxCall& eax_call);
 247
 248
 249     void validate_low_gain(
 250         long lLowGain);
 251
 252     void validate_low_cutoff(
 253         float flLowCutOff);
 254
 255     void validate_mid1_gain(
 256         long lMid1Gain);
 257
 258     void validate_mid1_center(
 259         float flMid1Center);
 260
 261     void validate_mid1_width(
 262         float flMid1Width);
 263
 264     void validate_mid2_gain(
 265         long lMid2Gain);
 266
 267     void validate_mid2_center(
 268         float flMid2Center);
 269
 270     void validate_mid2_width(
 271         float flMid2Width);
 272
 273     void validate_high_gain(
 274         long lHighGain);
 275
 276     void validate_high_cutoff(
 277         float flHighCutOff);
 278
 279     void validate_all(
 280         const EAXEQUALIZERPROPERTIES& all);
 281
 282
 283     void defer_low_gain(
 284         long lLowGain);
 285
 286     void defer_low_cutoff(
 287         float flLowCutOff);
 288
 289     void defer_mid1_gain(
 290         long lMid1Gain);
 291
 292     void defer_mid1_center(
 293         float flMid1Center);
 294
 295     void defer_mid1_width(
 296         float flMid1Width);
 297
 298     void defer_mid2_gain(
 299         long lMid2Gain);
 300
 301     void defer_mid2_center(
 302         float flMid2Center);
 303
 304     void defer_mid2_width(
 305         float flMid2Width);
 306
 307     void defer_high_gain(
 308         long lHighGain);
 309
 310     void defer_high_cutoff(
 311         float flHighCutOff);
 312
 313     void defer_all(
 314         const EAXEQUALIZERPROPERTIES& all);
 315
 316
 317     void defer_low_gain(
 318         const EaxEaxCall& eax_call);
 319
 320     void defer_low_cutoff(
 321         const EaxEaxCall& eax_call);
 322
 323     void defer_mid1_gain(
 324         const EaxEaxCall& eax_call);
 325
 326     void defer_mid1_center(
 327         const EaxEaxCall& eax_call);
 328
 329     void defer_mid1_width(
 330         const EaxEaxCall& eax_call);
 331
 332     void defer_mid2_gain(
 333         const EaxEaxCall& eax_call);
 334
 335     void defer_mid2_center(
 336         const EaxEaxCall& eax_call);
 337
 338     void defer_mid2_width(
 339         const EaxEaxCall& eax_call);
 340
 341     void defer_high_gain(
 342         const EaxEaxCall& eax_call);
 343
 344     void defer_high_cutoff(
 345         const EaxEaxCall& eax_call);
 346
 347     void defer_all(
 348         const EaxEaxCall& eax_call);
 349
 350
 351     // [[nodiscard]]
 352     bool apply_deferred();
 353
 354     // [[nodiscard]]
 355     bool set(
 356         const EaxEaxCall& eax_call);
 357 }; // EaxEqualizerEffect
 358
 359
 360 class EaxEqualizerEffectException :
 361     public EaxException
 362 {
 363 public:
 364     explicit EaxEqualizerEffectException(
 365         const char* message)
 366         :
 367         EaxException{"EAX_EQUALIZER_EFFECT", message}
 368     {
 369     }
 370 }; // EaxEqualizerEffectException
 371
 372
 373 EaxEqualizerEffect::EaxEqualizerEffect()
 374     : EaxEffect{AL_EFFECT_EQUALIZER}
 375 {
 376     set_eax_defaults();
 377     set_efx_defaults();
 378 }
 379
 380 // [[nodiscard]]
 381 bool EaxEqualizerEffect::dispatch(
 382     const EaxEaxCall& eax_call)
 383 {
 384     return eax_call.is_get() ? get(eax_call) : set(eax_call);
 385 }
 386
 387 void EaxEqualizerEffect::set_eax_defaults()
 388 {
 389     eax_.lLowGain = EAXEQUALIZER_DEFAULTLOWGAIN;
 390     eax_.flLowCutOff = EAXEQUALIZER_DEFAULTLOWCUTOFF;
 391     eax_.lMid1Gain = EAXEQUALIZER_DEFAULTMID1GAIN;
 392     eax_.flMid1Center = EAXEQUALIZER_DEFAULTMID1CENTER;
 393     eax_.flMid1Width = EAXEQUALIZER_DEFAULTMID1WIDTH;
 394     eax_.lMid2Gain = EAXEQUALIZER_DEFAULTMID2GAIN;
 395     eax_.flMid2Center = EAXEQUALIZER_DEFAULTMID2CENTER;
 396     eax_.flMid2Width = EAXEQUALIZER_DEFAULTMID2WIDTH;
 397     eax_.lHighGain = EAXEQUALIZER_DEFAULTHIGHGAIN;
 398     eax_.flHighCutOff = EAXEQUALIZER_DEFAULTHIGHCUTOFF;
 399
 400     eax_d_ = eax_;
 401 }
 402
 403 void EaxEqualizerEffect::set_efx_low_gain()
 404 {
 405     const auto low_gain = clamp(
 406         level_mb_to_gain(static_cast<float>(eax_.lLowGain)),
 407         AL_EQUALIZER_MIN_LOW_GAIN,
 408         AL_EQUALIZER_MAX_LOW_GAIN);
 409
 410     al_effect_props_.Equalizer.LowGain = low_gain;
 411 }
 412
 413 void EaxEqualizerEffect::set_efx_low_cutoff()
 414 {
 415     const auto low_cutoff = clamp(
 416         eax_.flLowCutOff,
 417         AL_EQUALIZER_MIN_LOW_CUTOFF,
 418         AL_EQUALIZER_MAX_LOW_CUTOFF);
 419
 420     al_effect_props_.Equalizer.LowCutoff = low_cutoff;
 421 }
 422
 423 void EaxEqualizerEffect::set_efx_mid1_gain()
 424 {
 425     const auto mid1_gain = clamp(
 426         level_mb_to_gain(static_cast<float>(eax_.lMid1Gain)),
 427         AL_EQUALIZER_MIN_MID1_GAIN,
 428         AL_EQUALIZER_MAX_MID1_GAIN);
 429
 430     al_effect_props_.Equalizer.Mid1Gain = mid1_gain;
 431 }
 432
 433 void EaxEqualizerEffect::set_efx_mid1_center()
 434 {
 435     const auto mid1_center = clamp(
 436         eax_.flMid1Center,
 437         AL_EQUALIZER_MIN_MID1_CENTER,
 438         AL_EQUALIZER_MAX_MID1_CENTER);
 439
 440     al_effect_props_.Equalizer.Mid1Center = mid1_center;
 441 }
 442
 443 void EaxEqualizerEffect::set_efx_mid1_width()
 444 {
 445     const auto mid1_width = clamp(
 446         eax_.flMid1Width,
 447         AL_EQUALIZER_MIN_MID1_WIDTH,
 448         AL_EQUALIZER_MAX_MID1_WIDTH);
 449
 450     al_effect_props_.Equalizer.Mid1Width = mid1_width;
 451 }
 452
 453 void EaxEqualizerEffect::set_efx_mid2_gain()
 454 {
 455     const auto mid2_gain = clamp(
 456         level_mb_to_gain(static_cast<float>(eax_.lMid2Gain)),
 457         AL_EQUALIZER_MIN_MID2_GAIN,
 458         AL_EQUALIZER_MAX_MID2_GAIN);
 459
 460     al_effect_props_.Equalizer.Mid2Gain = mid2_gain;
 461 }
 462
 463 void EaxEqualizerEffect::set_efx_mid2_center()
 464 {
 465     const auto mid2_center = clamp(
 466         eax_.flMid2Center,
 467         AL_EQUALIZER_MIN_MID2_CENTER,
 468         AL_EQUALIZER_MAX_MID2_CENTER);
 469
 470     al_effect_props_.Equalizer.Mid2Center = mid2_center;
 471 }
 472
 473 void EaxEqualizerEffect::set_efx_mid2_width()
 474 {
 475     const auto mid2_width = clamp(
 476         eax_.flMid2Width,
 477         AL_EQUALIZER_MIN_MID2_WIDTH,
 478         AL_EQUALIZER_MAX_MID2_WIDTH);
 479
 480     al_effect_props_.Equalizer.Mid2Width = mid2_width;
 481 }
 482
 483 void EaxEqualizerEffect::set_efx_high_gain()
 484 {
 485     const auto high_gain = clamp(
 486         level_mb_to_gain(static_cast<float>(eax_.lHighGain)),
 487         AL_EQUALIZER_MIN_HIGH_GAIN,
 488         AL_EQUALIZER_MAX_HIGH_GAIN);
 489
 490     al_effect_props_.Equalizer.HighGain = high_gain;
 491 }
 492
 493 void EaxEqualizerEffect::set_efx_high_cutoff()
 494 {
 495     const auto high_cutoff = clamp(
 496         eax_.flHighCutOff,
 497         AL_EQUALIZER_MIN_HIGH_CUTOFF,
 498         AL_EQUALIZER_MAX_HIGH_CUTOFF);
 499
 500     al_effect_props_.Equalizer.HighCutoff = high_cutoff;
 501 }
 502
 503 void EaxEqualizerEffect::set_efx_defaults()
 504 {
 505     set_efx_low_gain();
 506     set_efx_low_cutoff();
 507     set_efx_mid1_gain();
 508     set_efx_mid1_center();
 509     set_efx_mid1_width();
 510     set_efx_mid2_gain();
 511     set_efx_mid2_center();
 512     set_efx_mid2_width();
 513     set_efx_high_gain();
 514     set_efx_high_cutoff();
 515 }
 516
 517 // [[nodiscard]]
 518 bool EaxEqualizerEffect::get(
 519     const EaxEaxCall& eax_call)
 520 {
 521     switch (eax_call.get_property_id())
 522     {
 523         case EAXEQUALIZER_NONE:
 524             break;
 525
 526         case EAXEQUALIZER_ALLPARAMETERS:
 527             eax_call.set_value<EaxEqualizerEffectException>(eax_);
 528             break;
 529
 530         case EAXEQUALIZER_LOWGAIN:
 531             eax_call.set_value<EaxEqualizerEffectException>(eax_.lLowGain);
 532             break;
 533
 534         case EAXEQUALIZER_LOWCUTOFF:
 535             eax_call.set_value<EaxEqualizerEffectException>(eax_.flLowCutOff);
 536             break;
 537
 538         case EAXEQUALIZER_MID1GAIN:
 539             eax_call.set_value<EaxEqualizerEffectException>(eax_.lMid1Gain);
 540             break;
 541
 542         case EAXEQUALIZER_MID1CENTER:
 543             eax_call.set_value<EaxEqualizerEffectException>(eax_.flMid1Center);
 544             break;
 545
 546         case EAXEQUALIZER_MID1WIDTH:
 547             eax_call.set_value<EaxEqualizerEffectException>(eax_.flMid1Width);
 548             break;
 549
 550         case EAXEQUALIZER_MID2GAIN:
 551             eax_call.set_value<EaxEqualizerEffectException>(eax_.lMid2Gain);
 552             break;
 553
 554         case EAXEQUALIZER_MID2CENTER:
 555             eax_call.set_value<EaxEqualizerEffectException>(eax_.flMid2Center);
 556             break;
 557
 558         case EAXEQUALIZER_MID2WIDTH:
 559             eax_call.set_value<EaxEqualizerEffectException>(eax_.flMid2Width);
 560             break;
 561
 562         case EAXEQUALIZER_HIGHGAIN:
 563             eax_call.set_value<EaxEqualizerEffectException>(eax_.lHighGain);
 564             break;
 565
 566         case EAXEQUALIZER_HIGHCUTOFF:
 567             eax_call.set_value<EaxEqualizerEffectException>(eax_.flHighCutOff);
 568             break;
 569
 570         default:
 571             throw EaxEqualizerEffectException{"Unsupported property id."};
 572     }
 573
 574     return false;
 575 }
 576
 577 void EaxEqualizerEffect::validate_low_gain(
 578     long lLowGain)
 579 {
 580     eax_validate_range<EaxEqualizerEffectException>(
 581         "Low Gain",
 582         lLowGain,
 583         EAXEQUALIZER_MINLOWGAIN,
 584         EAXEQUALIZER_MAXLOWGAIN);
 585 }
 586
 587 void EaxEqualizerEffect::validate_low_cutoff(
 588     float flLowCutOff)
 589 {
 590     eax_validate_range<EaxEqualizerEffectException>(
 591         "Low Cutoff",
 592         flLowCutOff,
 593         EAXEQUALIZER_MINLOWCUTOFF,
 594         EAXEQUALIZER_MAXLOWCUTOFF);
 595 }
 596
 597 void EaxEqualizerEffect::validate_mid1_gain(
 598     long lMid1Gain)
 599 {
 600     eax_validate_range<EaxEqualizerEffectException>(
 601         "Mid1 Gain",
 602         lMid1Gain,
 603         EAXEQUALIZER_MINMID1GAIN,
 604         EAXEQUALIZER_MAXMID1GAIN);
 605 }
 606
 607 void EaxEqualizerEffect::validate_mid1_center(
 608     float flMid1Center)
 609 {
 610     eax_validate_range<EaxEqualizerEffectException>(
 611         "Mid1 Center",
 612         flMid1Center,
 613         EAXEQUALIZER_MINMID1CENTER,
 614         EAXEQUALIZER_MAXMID1CENTER);
 615 }
 616
 617 void EaxEqualizerEffect::validate_mid1_width(
 618     float flMid1Width)
 619 {
 620     eax_validate_range<EaxEqualizerEffectException>(
 621         "Mid1 Width",
 622         flMid1Width,
 623         EAXEQUALIZER_MINMID1WIDTH,
 624         EAXEQUALIZER_MAXMID1WIDTH);
 625 }
 626
 627 void EaxEqualizerEffect::validate_mid2_gain(
 628     long lMid2Gain)
 629 {
 630     eax_validate_range<EaxEqualizerEffectException>(
 631         "Mid2 Gain",
 632         lMid2Gain,
 633         EAXEQUALIZER_MINMID2GAIN,
 634         EAXEQUALIZER_MAXMID2GAIN);
 635 }
 636
 637 void EaxEqualizerEffect::validate_mid2_center(
 638     float flMid2Center)
 639 {
 640     eax_validate_range<EaxEqualizerEffectException>(
 641         "Mid2 Center",
 642         flMid2Center,
 643         EAXEQUALIZER_MINMID2CENTER,
 644         EAXEQUALIZER_MAXMID2CENTER);
 645 }
 646
 647 void EaxEqualizerEffect::validate_mid2_width(
 648     float flMid2Width)
 649 {
 650     eax_validate_range<EaxEqualizerEffectException>(
 651         "Mid2 Width",
 652         flMid2Width,
 653         EAXEQUALIZER_MINMID2WIDTH,
 654         EAXEQUALIZER_MAXMID2WIDTH);
 655 }
 656
 657 void EaxEqualizerEffect::validate_high_gain(
 658     long lHighGain)
 659 {
 660     eax_validate_range<EaxEqualizerEffectException>(
 661         "High Gain",
 662         lHighGain,
 663         EAXEQUALIZER_MINHIGHGAIN,
 664         EAXEQUALIZER_MAXHIGHGAIN);
 665 }
 666
 667 void EaxEqualizerEffect::validate_high_cutoff(
 668     float flHighCutOff)
 669 {
 670     eax_validate_range<EaxEqualizerEffectException>(
 671         "High Cutoff",
 672         flHighCutOff,
 673         EAXEQUALIZER_MINHIGHCUTOFF,
 674         EAXEQUALIZER_MAXHIGHCUTOFF);
 675 }
 676
 677 void EaxEqualizerEffect::validate_all(
 678     const EAXEQUALIZERPROPERTIES& all)
 679 {
 680     validate_low_gain(all.lLowGain);
 681     validate_low_cutoff(all.flLowCutOff);
 682     validate_mid1_gain(all.lMid1Gain);
 683     validate_mid1_center(all.flMid1Center);
 684     validate_mid1_width(all.flMid1Width);
 685     validate_mid2_gain(all.lMid2Gain);
 686     validate_mid2_center(all.flMid2Center);
 687     validate_mid2_width(all.flMid2Width);
 688     validate_high_gain(all.lHighGain);
 689     validate_high_cutoff(all.flHighCutOff);
 690 }
 691
 692 void EaxEqualizerEffect::defer_low_gain(
 693     long lLowGain)
 694 {
 695     eax_d_.lLowGain = lLowGain;
 696     eax_dirty_flags_.lLowGain = (eax_.lLowGain != eax_d_.lLowGain);
 697 }
 698
 699 void EaxEqualizerEffect::defer_low_cutoff(
 700     float flLowCutOff)
 701 {
 702     eax_d_.flLowCutOff = flLowCutOff;
 703     eax_dirty_flags_.flLowCutOff = (eax_.flLowCutOff != eax_d_.flLowCutOff);
 704 }
 705
 706 void EaxEqualizerEffect::defer_mid1_gain(
 707     long lMid1Gain)
 708 {
 709     eax_d_.lMid1Gain = lMid1Gain;
 710     eax_dirty_flags_.lMid1Gain = (eax_.lMid1Gain != eax_d_.lMid1Gain);
 711 }
 712
 713 void EaxEqualizerEffect::defer_mid1_center(
 714     float flMid1Center)
 715 {
 716     eax_d_.flMid1Center = flMid1Center;
 717     eax_dirty_flags_.flMid1Center = (eax_.flMid1Center != eax_d_.flMid1Center);
 718 }
 719
 720 void EaxEqualizerEffect::defer_mid1_width(
 721     float flMid1Width)
 722 {
 723     eax_d_.flMid1Width = flMid1Width;
 724     eax_dirty_flags_.flMid1Width = (eax_.flMid1Width != eax_d_.flMid1Width);
 725 }
 726
 727 void EaxEqualizerEffect::defer_mid2_gain(
 728     long lMid2Gain)
 729 {
 730     eax_d_.lMid2Gain = lMid2Gain;
 731     eax_dirty_flags_.lMid2Gain = (eax_.lMid2Gain != eax_d_.lMid2Gain);
 732 }
 733
 734 void EaxEqualizerEffect::defer_mid2_center(
 735     float flMid2Center)
 736 {
 737     eax_d_.flMid2Center = flMid2Center;
 738     eax_dirty_flags_.flMid2Center = (eax_.flMid2Center != eax_d_.flMid2Center);
 739 }
 740
 741 void EaxEqualizerEffect::defer_mid2_width(
 742     float flMid2Width)
 743 {
 744     eax_d_.flMid2Width = flMid2Width;
 745     eax_dirty_flags_.flMid2Width = (eax_.flMid2Width != eax_d_.flMid2Width);
 746 }
 747
 748 void EaxEqualizerEffect::defer_high_gain(
 749     long lHighGain)
 750 {
 751     eax_d_.lHighGain = lHighGain;
 752     eax_dirty_flags_.lHighGain = (eax_.lHighGain != eax_d_.lHighGain);
 753 }
 754
 755 void EaxEqualizerEffect::defer_high_cutoff(
 756     float flHighCutOff)
 757 {
 758     eax_d_.flHighCutOff = flHighCutOff;
 759     eax_dirty_flags_.flHighCutOff = (eax_.flHighCutOff != eax_d_.flHighCutOff);
 760 }
 761
 762 void EaxEqualizerEffect::defer_all(
 763     const EAXEQUALIZERPROPERTIES& all)
 764 {
 765     defer_low_gain(all.lLowGain);
 766     defer_low_cutoff(all.flLowCutOff);
 767     defer_mid1_gain(all.lMid1Gain);
 768     defer_mid1_center(all.flMid1Center);
 769     defer_mid1_width(all.flMid1Width);
 770     defer_mid2_gain(all.lMid2Gain);
 771     defer_mid2_center(all.flMid2Center);
 772     defer_mid2_width(all.flMid2Width);
 773     defer_high_gain(all.lHighGain);
 774     defer_high_cutoff(all.flHighCutOff);
 775 }
 776
 777 void EaxEqualizerEffect::defer_low_gain(
 778     const EaxEaxCall& eax_call)
 779 {
 780     const auto& low_gain =
 781         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::lLowGain)>();
 782
 783     validate_low_gain(low_gain);
 784     defer_low_gain(low_gain);
 785 }
 786
 787 void EaxEqualizerEffect::defer_low_cutoff(
 788     const EaxEaxCall& eax_call)
 789 {
 790     const auto& low_cutoff =
 791         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::flLowCutOff)>();
 792
 793     validate_low_cutoff(low_cutoff);
 794     defer_low_cutoff(low_cutoff);
 795 }
 796
 797 void EaxEqualizerEffect::defer_mid1_gain(
 798     const EaxEaxCall& eax_call)
 799 {
 800     const auto& mid1_gain =
 801         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::lMid1Gain)>();
 802
 803     validate_mid1_gain(mid1_gain);
 804     defer_mid1_gain(mid1_gain);
 805 }
 806
 807 void EaxEqualizerEffect::defer_mid1_center(
 808     const EaxEaxCall& eax_call)
 809 {
 810     const auto& mid1_center =
 811         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::flMid1Center)>();
 812
 813     validate_mid1_center(mid1_center);
 814     defer_mid1_center(mid1_center);
 815 }
 816
 817 void EaxEqualizerEffect::defer_mid1_width(
 818     const EaxEaxCall& eax_call)
 819 {
 820     const auto& mid1_width =
 821         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::flMid1Width)>();
 822
 823     validate_mid1_width(mid1_width);
 824     defer_mid1_width(mid1_width);
 825 }
 826
 827 void EaxEqualizerEffect::defer_mid2_gain(
 828     const EaxEaxCall& eax_call)
 829 {
 830     const auto& mid2_gain =
 831         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::lMid2Gain)>();
 832
 833     validate_mid2_gain(mid2_gain);
 834     defer_mid2_gain(mid2_gain);
 835 }
 836
 837 void EaxEqualizerEffect::defer_mid2_center(
 838     const EaxEaxCall& eax_call)
 839 {
 840     const auto& mid2_center =
 841         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::flMid2Center)>();
 842
 843     validate_mid2_center(mid2_center);
 844     defer_mid2_center(mid2_center);
 845 }
 846
 847 void EaxEqualizerEffect::defer_mid2_width(
 848     const EaxEaxCall& eax_call)
 849 {
 850     const auto& mid2_width =
 851         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::flMid2Width)>();
 852
 853     validate_mid2_width(mid2_width);
 854     defer_mid2_width(mid2_width);
 855 }
 856
 857 void EaxEqualizerEffect::defer_high_gain(
 858     const EaxEaxCall& eax_call)
 859 {
 860     const auto& high_gain =
 861         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::lHighGain)>();
 862
 863     validate_high_gain(high_gain);
 864     defer_high_gain(high_gain);
 865 }
 866
 867 void EaxEqualizerEffect::defer_high_cutoff(
 868     const EaxEaxCall& eax_call)
 869 {
 870     const auto& high_cutoff =
 871         eax_call.get_value<EaxEqualizerEffectException, const decltype(EAXEQUALIZERPROPERTIES::flHighCutOff)>();
 872
 873     validate_high_cutoff(high_cutoff);
 874     defer_high_cutoff(high_cutoff);
 875 }
 876
 877 void EaxEqualizerEffect::defer_all(
 878     const EaxEaxCall& eax_call)
 879 {
 880     const auto& all =
 881         eax_call.get_value<EaxEqualizerEffectException, const EAXEQUALIZERPROPERTIES>();
 882
 883     validate_all(all);
 884     defer_all(all);
 885 }
 886
 887 // [[nodiscard]]
 888 bool EaxEqualizerEffect::apply_deferred()
 889 {
 890     if (eax_dirty_flags_ == EaxEqualizerEffectDirtyFlags{})
 891     {
 892         return false;
 893     }
 894
 895     eax_ = eax_d_;
 896
 897     if (eax_dirty_flags_.lLowGain)
 898     {
 899         set_efx_low_gain();
 900     }
 901
 902     if (eax_dirty_flags_.flLowCutOff)
 903     {
 904         set_efx_low_cutoff();
 905     }
 906
 907     if (eax_dirty_flags_.lMid1Gain)
 908     {
 909         set_efx_mid1_gain();
 910     }
 911
 912     if (eax_dirty_flags_.flMid1Center)
 913     {
 914         set_efx_mid1_center();
 915     }
 916
 917     if (eax_dirty_flags_.flMid1Width)
 918     {
 919         set_efx_mid1_width();
 920     }
 921
 922     if (eax_dirty_flags_.lMid2Gain)
 923     {
 924         set_efx_mid2_gain();
 925     }
 926
 927     if (eax_dirty_flags_.flMid2Center)
 928     {
 929         set_efx_mid2_center();
 930     }
 931
 932     if (eax_dirty_flags_.flMid2Width)
 933     {
 934         set_efx_mid2_width();
 935     }
 936
 937     if (eax_dirty_flags_.lHighGain)
 938     {
 939         set_efx_high_gain();
 940     }
 941
 942     if (eax_dirty_flags_.flHighCutOff)
 943     {
 944         set_efx_high_cutoff();
 945     }
 946
 947     eax_dirty_flags_ = EaxEqualizerEffectDirtyFlags{};
 948
 949     return true;
 950 }
 951
 952 // [[nodiscard]]
 953 bool EaxEqualizerEffect::set(
 954     const EaxEaxCall& eax_call)
 955 {
 956     switch (eax_call.get_property_id())
 957     {
 958         case EAXEQUALIZER_NONE:
 959             break;
 960
 961         case EAXEQUALIZER_ALLPARAMETERS:
 962             defer_all(eax_call);
 963             break;
 964
 965         case EAXEQUALIZER_LOWGAIN:
 966             defer_low_gain(eax_call);
 967             break;
 968
 969         case EAXEQUALIZER_LOWCUTOFF:
 970             defer_low_cutoff(eax_call);
 971             break;
 972
 973         case EAXEQUALIZER_MID1GAIN:
 974             defer_mid1_gain(eax_call);
 975             break;
 976
 977         case EAXEQUALIZER_MID1CENTER:
 978             defer_mid1_center(eax_call);
 979             break;
 980
 981         case EAXEQUALIZER_MID1WIDTH:
 982             defer_mid1_width(eax_call);
 983             break;
 984
 985         case EAXEQUALIZER_MID2GAIN:
 986             defer_mid2_gain(eax_call);
 987             break;
 988
 989         case EAXEQUALIZER_MID2CENTER:
 990             defer_mid2_center(eax_call);
 991             break;
 992
 993         case EAXEQUALIZER_MID2WIDTH:
 994             defer_mid2_width(eax_call);
 995             break;
 996
 997         case EAXEQUALIZER_HIGHGAIN:
 998             defer_high_gain(eax_call);
 999             break;
1000
1001         case EAXEQUALIZER_HIGHCUTOFF:
1002             defer_high_cutoff(eax_call);
1003             break;
1004
1005         default:
1006             throw EaxEqualizerEffectException{"Unsupported property id."};
1007     }
1008
1009     if (!eax_call.is_deferred())
1010     {
1011         return apply_deferred();
1012     }
1013
1014     return false;
1015 }
1016
1017 } // namespace
1018
1019 EaxEffectUPtr eax_create_eax_equalizer_effect()
1020 {
1021     return std::make_unique<EaxEqualizerEffect>();
1022 }
1023
1024 #endif // ALSOFT_EAX