al/effects/chorus.cpp

   1
   2 #include "config.h"
   3
   4 #include <stdexcept>
   5
   6 #include "AL/al.h"
   7 #include "AL/efx.h"
   8
   9 #include "alc/effects/base.h"
  10 #include "aloptional.h"
  11 #include "core/logging.h"
  12 #include "effects.h"
  13
  14 #ifdef ALSOFT_EAX
  15 #include <cassert>
  16
  17 #include "alnumeric.h"
  18
  19 #include "al/eax_exception.h"
  20 #include "al/eax_utils.h"
  21 #endif // ALSOFT_EAX
  22
  23
  24 namespace {
  25
  26 static_assert(ChorusMaxDelay >= AL_CHORUS_MAX_DELAY, "Chorus max delay too small");
  27 static_assert(FlangerMaxDelay >= AL_FLANGER_MAX_DELAY, "Flanger max delay too small");
  28
  29 static_assert(AL_CHORUS_WAVEFORM_SINUSOID == AL_FLANGER_WAVEFORM_SINUSOID, "Chorus/Flanger waveform value mismatch");
  30 static_assert(AL_CHORUS_WAVEFORM_TRIANGLE == AL_FLANGER_WAVEFORM_TRIANGLE, "Chorus/Flanger waveform value mismatch");
  31
  32 inline al::optional<ChorusWaveform> WaveformFromEnum(ALenum type)
  33 {
  34     switch(type)
  35     {
  36     case AL_CHORUS_WAVEFORM_SINUSOID: return al::make_optional(ChorusWaveform::Sinusoid);
  37     case AL_CHORUS_WAVEFORM_TRIANGLE: return al::make_optional(ChorusWaveform::Triangle);
  38     }
  39     return al::nullopt;
  40 }
  41 inline ALenum EnumFromWaveform(ChorusWaveform type)
  42 {
  43     switch(type)
  44     {
  45     case ChorusWaveform::Sinusoid: return AL_CHORUS_WAVEFORM_SINUSOID;
  46     case ChorusWaveform::Triangle: return AL_CHORUS_WAVEFORM_TRIANGLE;
  47     }
  48     throw std::runtime_error{"Invalid chorus waveform: "+std::to_string(static_cast<int>(type))};
  49 }
  50
  51 void Chorus_setParami(EffectProps *props, ALenum param, int val)
  52 {
  53     switch(param)
  54     {
  55     case AL_CHORUS_WAVEFORM:
  56         if(auto formopt = WaveformFromEnum(val))
  57             props->Chorus.Waveform = *formopt;
  58         else
  59             throw effect_exception{AL_INVALID_VALUE, "Invalid chorus waveform: 0x%04x", val};
  60         break;
  61
  62     case AL_CHORUS_PHASE:
  63         if(!(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE))
  64             throw effect_exception{AL_INVALID_VALUE, "Chorus phase out of range: %d", val};
  65         props->Chorus.Phase = val;
  66         break;
  67
  68     default:
  69         throw effect_exception{AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param};
  70     }
  71 }
  72 void Chorus_setParamiv(EffectProps *props, ALenum param, const int *vals)
  73 { Chorus_setParami(props, param, vals[0]); }
  74 void Chorus_setParamf(EffectProps *props, ALenum param, float val)
  75 {
  76     switch(param)
  77     {
  78     case AL_CHORUS_RATE:
  79         if(!(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE))
  80             throw effect_exception{AL_INVALID_VALUE, "Chorus rate out of range: %f", val};
  81         props->Chorus.Rate = val;
  82         break;
  83
  84     case AL_CHORUS_DEPTH:
  85         if(!(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH))
  86             throw effect_exception{AL_INVALID_VALUE, "Chorus depth out of range: %f", val};
  87         props->Chorus.Depth = val;
  88         break;
  89
  90     case AL_CHORUS_FEEDBACK:
  91         if(!(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK))
  92             throw effect_exception{AL_INVALID_VALUE, "Chorus feedback out of range: %f", val};
  93         props->Chorus.Feedback = val;
  94         break;
  95
  96     case AL_CHORUS_DELAY:
  97         if(!(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY))
  98             throw effect_exception{AL_INVALID_VALUE, "Chorus delay out of range: %f", val};
  99         props->Chorus.Delay = val;
 100         break;
 101
 102     default:
 103         throw effect_exception{AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param};
 104     }
 105 }
 106 void Chorus_setParamfv(EffectProps *props, ALenum param, const float *vals)
 107 { Chorus_setParamf(props, param, vals[0]); }
 108
 109 void Chorus_getParami(const EffectProps *props, ALenum param, int *val)
 110 {
 111     switch(param)
 112     {
 113     case AL_CHORUS_WAVEFORM:
 114         *val = EnumFromWaveform(props->Chorus.Waveform);
 115         break;
 116
 117     case AL_CHORUS_PHASE:
 118         *val = props->Chorus.Phase;
 119         break;
 120
 121     default:
 122         throw effect_exception{AL_INVALID_ENUM, "Invalid chorus integer property 0x%04x", param};
 123     }
 124 }
 125 void Chorus_getParamiv(const EffectProps *props, ALenum param, int *vals)
 126 { Chorus_getParami(props, param, vals); }
 127 void Chorus_getParamf(const EffectProps *props, ALenum param, float *val)
 128 {
 129     switch(param)
 130     {
 131     case AL_CHORUS_RATE:
 132         *val = props->Chorus.Rate;
 133         break;
 134
 135     case AL_CHORUS_DEPTH:
 136         *val = props->Chorus.Depth;
 137         break;
 138
 139     case AL_CHORUS_FEEDBACK:
 140         *val = props->Chorus.Feedback;
 141         break;
 142
 143     case AL_CHORUS_DELAY:
 144         *val = props->Chorus.Delay;
 145         break;
 146
 147     default:
 148         throw effect_exception{AL_INVALID_ENUM, "Invalid chorus float property 0x%04x", param};
 149     }
 150 }
 151 void Chorus_getParamfv(const EffectProps *props, ALenum param, float *vals)
 152 { Chorus_getParamf(props, param, vals); }
 153
 154 const EffectProps genDefaultChorusProps() noexcept
 155 {
 156     EffectProps props{};
 157     props.Chorus.Waveform = *WaveformFromEnum(AL_CHORUS_DEFAULT_WAVEFORM);
 158     props.Chorus.Phase = AL_CHORUS_DEFAULT_PHASE;
 159     props.Chorus.Rate = AL_CHORUS_DEFAULT_RATE;
 160     props.Chorus.Depth = AL_CHORUS_DEFAULT_DEPTH;
 161     props.Chorus.Feedback = AL_CHORUS_DEFAULT_FEEDBACK;
 162     props.Chorus.Delay = AL_CHORUS_DEFAULT_DELAY;
 163     return props;
 164 }
 165
 166
 167 void Flanger_setParami(EffectProps *props, ALenum param, int val)
 168 {
 169     switch(param)
 170     {
 171     case AL_FLANGER_WAVEFORM:
 172         if(auto formopt = WaveformFromEnum(val))
 173             props->Chorus.Waveform = *formopt;
 174         else
 175             throw effect_exception{AL_INVALID_VALUE, "Invalid flanger waveform: 0x%04x", val};
 176         break;
 177
 178     case AL_FLANGER_PHASE:
 179         if(!(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE))
 180             throw effect_exception{AL_INVALID_VALUE, "Flanger phase out of range: %d", val};
 181         props->Chorus.Phase = val;
 182         break;
 183
 184     default:
 185         throw effect_exception{AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param};
 186     }
 187 }
 188 void Flanger_setParamiv(EffectProps *props, ALenum param, const int *vals)
 189 { Flanger_setParami(props, param, vals[0]); }
 190 void Flanger_setParamf(EffectProps *props, ALenum param, float val)
 191 {
 192     switch(param)
 193     {
 194     case AL_FLANGER_RATE:
 195         if(!(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE))
 196             throw effect_exception{AL_INVALID_VALUE, "Flanger rate out of range: %f", val};
 197         props->Chorus.Rate = val;
 198         break;
 199
 200     case AL_FLANGER_DEPTH:
 201         if(!(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH))
 202             throw effect_exception{AL_INVALID_VALUE, "Flanger depth out of range: %f", val};
 203         props->Chorus.Depth = val;
 204         break;
 205
 206     case AL_FLANGER_FEEDBACK:
 207         if(!(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK))
 208             throw effect_exception{AL_INVALID_VALUE, "Flanger feedback out of range: %f", val};
 209         props->Chorus.Feedback = val;
 210         break;
 211
 212     case AL_FLANGER_DELAY:
 213         if(!(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY))
 214             throw effect_exception{AL_INVALID_VALUE, "Flanger delay out of range: %f", val};
 215         props->Chorus.Delay = val;
 216         break;
 217
 218     default:
 219         throw effect_exception{AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param};
 220     }
 221 }
 222 void Flanger_setParamfv(EffectProps *props, ALenum param, const float *vals)
 223 { Flanger_setParamf(props, param, vals[0]); }
 224
 225 void Flanger_getParami(const EffectProps *props, ALenum param, int *val)
 226 {
 227     switch(param)
 228     {
 229     case AL_FLANGER_WAVEFORM:
 230         *val = EnumFromWaveform(props->Chorus.Waveform);
 231         break;
 232
 233     case AL_FLANGER_PHASE:
 234         *val = props->Chorus.Phase;
 235         break;
 236
 237     default:
 238         throw effect_exception{AL_INVALID_ENUM, "Invalid flanger integer property 0x%04x", param};
 239     }
 240 }
 241 void Flanger_getParamiv(const EffectProps *props, ALenum param, int *vals)
 242 { Flanger_getParami(props, param, vals); }
 243 void Flanger_getParamf(const EffectProps *props, ALenum param, float *val)
 244 {
 245     switch(param)
 246     {
 247     case AL_FLANGER_RATE:
 248         *val = props->Chorus.Rate;
 249         break;
 250
 251     case AL_FLANGER_DEPTH:
 252         *val = props->Chorus.Depth;
 253         break;
 254
 255     case AL_FLANGER_FEEDBACK:
 256         *val = props->Chorus.Feedback;
 257         break;
 258
 259     case AL_FLANGER_DELAY:
 260         *val = props->Chorus.Delay;
 261         break;
 262
 263     default:
 264         throw effect_exception{AL_INVALID_ENUM, "Invalid flanger float property 0x%04x", param};
 265     }
 266 }
 267 void Flanger_getParamfv(const EffectProps *props, ALenum param, float *vals)
 268 { Flanger_getParamf(props, param, vals); }
 269
 270 EffectProps genDefaultFlangerProps() noexcept
 271 {
 272     EffectProps props{};
 273     props.Chorus.Waveform = *WaveformFromEnum(AL_FLANGER_DEFAULT_WAVEFORM);
 274     props.Chorus.Phase = AL_FLANGER_DEFAULT_PHASE;
 275     props.Chorus.Rate = AL_FLANGER_DEFAULT_RATE;
 276     props.Chorus.Depth = AL_FLANGER_DEFAULT_DEPTH;
 277     props.Chorus.Feedback = AL_FLANGER_DEFAULT_FEEDBACK;
 278     props.Chorus.Delay = AL_FLANGER_DEFAULT_DELAY;
 279     return props;
 280 }
 281
 282 } // namespace
 283
 284 DEFINE_ALEFFECT_VTABLE(Chorus);
 285
 286 const EffectProps ChorusEffectProps{genDefaultChorusProps()};
 287
 288 DEFINE_ALEFFECT_VTABLE(Flanger);
 289
 290 const EffectProps FlangerEffectProps{genDefaultFlangerProps()};
 291
 292
 293 #ifdef ALSOFT_EAX
 294 namespace {
 295
 296 void eax_set_efx_waveform(
 297     ALenum waveform,
 298     EffectProps& al_effect_props)
 299 {
 300     const auto efx_waveform = WaveformFromEnum(waveform);
 301     assert(efx_waveform.has_value());
 302     al_effect_props.Chorus.Waveform = *efx_waveform;
 303 }
 304
 305 void eax_set_efx_phase(
 306     ALint phase,
 307     EffectProps& al_effect_props)
 308 {
 309     al_effect_props.Chorus.Phase = phase;
 310 }
 311
 312 void eax_set_efx_rate(
 313     ALfloat rate,
 314     EffectProps& al_effect_props)
 315 {
 316     al_effect_props.Chorus.Rate = rate;
 317 }
 318
 319 void eax_set_efx_depth(
 320     ALfloat depth,
 321     EffectProps& al_effect_props)
 322 {
 323     al_effect_props.Chorus.Depth = depth;
 324 }
 325
 326 void eax_set_efx_feedback(
 327     ALfloat feedback,
 328     EffectProps& al_effect_props)
 329 {
 330     al_effect_props.Chorus.Feedback = feedback;
 331 }
 332
 333 void eax_set_efx_delay(
 334     ALfloat delay,
 335     EffectProps& al_effect_props)
 336 {
 337     al_effect_props.Chorus.Delay = delay;
 338 }
 339
 340
 341 using EaxChorusEffectDirtyFlagsValue = std::uint_least8_t;
 342
 343 struct EaxChorusEffectDirtyFlags
 344 {
 345     using EaxIsBitFieldStruct = bool;
 346
 347     EaxChorusEffectDirtyFlagsValue ulWaveform : 1;
 348     EaxChorusEffectDirtyFlagsValue lPhase : 1;
 349     EaxChorusEffectDirtyFlagsValue flRate : 1;
 350     EaxChorusEffectDirtyFlagsValue flDepth : 1;
 351     EaxChorusEffectDirtyFlagsValue flFeedback : 1;
 352     EaxChorusEffectDirtyFlagsValue flDelay : 1;
 353 }; // EaxChorusEffectDirtyFlags
 354
 355
 356 class EaxChorusEffect final :
 357     public EaxEffect
 358 {
 359 public:
 360     EaxChorusEffect();
 361
 362
 363     // [[nodiscard]]
 364     bool dispatch(
 365         const EaxEaxCall& eax_call) override;
 366
 367
 368 private:
 369     EAXCHORUSPROPERTIES eax_{};
 370     EAXCHORUSPROPERTIES eax_d_{};
 371     EaxChorusEffectDirtyFlags eax_dirty_flags_{};
 372
 373
 374     void set_eax_defaults() noexcept;
 375
 376
 377     void set_efx_waveform();
 378
 379     void set_efx_phase();
 380
 381     void set_efx_rate();
 382
 383     void set_efx_depth();
 384
 385     void set_efx_feedback();
 386
 387     void set_efx_delay();
 388
 389     void set_efx_defaults();
 390
 391
 392     // [[nodiscard]]
 393     bool get(
 394         const EaxEaxCall& eax_call);
 395
 396
 397     void validate_waveform(
 398         unsigned long ulWaveform);
 399
 400     void validate_phase(
 401         long lPhase);
 402
 403     void validate_rate(
 404         float flRate);
 405
 406     void validate_depth(
 407         float flDepth);
 408
 409     void validate_feedback(
 410         float flFeedback);
 411
 412     void validate_delay(
 413         float flDelay);
 414
 415     void validate_all(
 416         const EAXCHORUSPROPERTIES& eax_all);
 417
 418
 419     void defer_waveform(
 420         unsigned long ulWaveform);
 421
 422     void defer_phase(
 423         long lPhase);
 424
 425     void defer_rate(
 426         float flRate);
 427
 428     void defer_depth(
 429         float flDepth);
 430
 431     void defer_feedback(
 432         float flFeedback);
 433
 434     void defer_delay(
 435         float flDelay);
 436
 437     void defer_all(
 438         const EAXCHORUSPROPERTIES& eax_all);
 439
 440
 441     void defer_waveform(
 442         const EaxEaxCall& eax_call);
 443
 444     void defer_phase(
 445         const EaxEaxCall& eax_call);
 446
 447     void defer_rate(
 448         const EaxEaxCall& eax_call);
 449
 450     void defer_depth(
 451         const EaxEaxCall& eax_call);
 452
 453     void defer_feedback(
 454         const EaxEaxCall& eax_call);
 455
 456     void defer_delay(
 457         const EaxEaxCall& eax_call);
 458
 459     void defer_all(
 460         const EaxEaxCall& eax_call);
 461
 462
 463     // [[nodiscard]]
 464     bool apply_deferred();
 465
 466     // [[nodiscard]]
 467     bool set(
 468         const EaxEaxCall& eax_call);
 469 }; // EaxChorusEffect
 470
 471
 472 class EaxChorusEffectException :
 473     public EaxException
 474 {
 475 public:
 476     explicit EaxChorusEffectException(
 477         const char* message)
 478         :
 479         EaxException{"EAX_CHORUS_EFFECT", message}
 480     {
 481     }
 482 }; // EaxChorusEffectException
 483
 484
 485 EaxChorusEffect::EaxChorusEffect()
 486     : EaxEffect{AL_EFFECT_CHORUS}
 487 {
 488     set_eax_defaults();
 489     set_efx_defaults();
 490 }
 491
 492 // [[nodiscard]]
 493 bool EaxChorusEffect::dispatch(
 494     const EaxEaxCall& eax_call)
 495 {
 496     return eax_call.is_get() ? get(eax_call) : set(eax_call);
 497 }
 498
 499 void EaxChorusEffect::set_eax_defaults() noexcept
 500 {
 501     eax_.ulWaveform = EAXCHORUS_DEFAULTWAVEFORM;
 502     eax_.lPhase = EAXCHORUS_DEFAULTPHASE;
 503     eax_.flRate = EAXCHORUS_DEFAULTRATE;
 504     eax_.flDepth = EAXCHORUS_DEFAULTDEPTH;
 505     eax_.flFeedback = EAXCHORUS_DEFAULTFEEDBACK;
 506     eax_.flDelay = EAXCHORUS_DEFAULTDELAY;
 507
 508     eax_d_ = eax_;
 509 }
 510
 511 void EaxChorusEffect::set_efx_waveform()
 512 {
 513     const auto waveform = clamp(
 514         static_cast<ALint>(eax_.ulWaveform),
 515         AL_CHORUS_MIN_WAVEFORM,
 516         AL_CHORUS_MAX_WAVEFORM);
 517
 518     eax_set_efx_waveform(waveform, al_effect_props_);
 519 }
 520
 521 void EaxChorusEffect::set_efx_phase()
 522 {
 523     const auto phase = clamp(
 524         static_cast<ALint>(eax_.lPhase),
 525         AL_CHORUS_MIN_PHASE,
 526         AL_CHORUS_MAX_PHASE);
 527
 528     eax_set_efx_phase(phase, al_effect_props_);
 529 }
 530
 531 void EaxChorusEffect::set_efx_rate()
 532 {
 533     const auto rate = clamp(
 534         eax_.flRate,
 535         AL_CHORUS_MIN_RATE,
 536         AL_CHORUS_MAX_RATE);
 537
 538     eax_set_efx_rate(rate, al_effect_props_);
 539 }
 540
 541 void EaxChorusEffect::set_efx_depth()
 542 {
 543     const auto depth = clamp(
 544         eax_.flDepth,
 545         AL_CHORUS_MIN_DEPTH,
 546         AL_CHORUS_MAX_DEPTH);
 547
 548     eax_set_efx_depth(depth, al_effect_props_);
 549 }
 550
 551 void EaxChorusEffect::set_efx_feedback()
 552 {
 553     const auto feedback = clamp(
 554         eax_.flFeedback,
 555         AL_CHORUS_MIN_FEEDBACK,
 556         AL_CHORUS_MAX_FEEDBACK);
 557
 558     eax_set_efx_feedback(feedback, al_effect_props_);
 559 }
 560
 561 void EaxChorusEffect::set_efx_delay()
 562 {
 563     const auto delay = clamp(
 564         eax_.flDelay,
 565         AL_CHORUS_MIN_DELAY,
 566         AL_CHORUS_MAX_DELAY);
 567
 568     eax_set_efx_delay(delay, al_effect_props_);
 569 }
 570
 571 void EaxChorusEffect::set_efx_defaults()
 572 {
 573     set_efx_waveform();
 574     set_efx_phase();
 575     set_efx_rate();
 576     set_efx_depth();
 577     set_efx_feedback();
 578     set_efx_delay();
 579 }
 580
 581 bool EaxChorusEffect::get(
 582     const EaxEaxCall& eax_call)
 583 {
 584     switch (eax_call.get_property_id())
 585     {
 586         case EAXCHORUS_NONE:
 587             break;
 588
 589         case EAXCHORUS_ALLPARAMETERS:
 590             eax_call.set_value<EaxChorusEffectException>(eax_);
 591             break;
 592
 593         case EAXCHORUS_WAVEFORM:
 594             eax_call.set_value<EaxChorusEffectException>(eax_.ulWaveform);
 595             break;
 596
 597         case EAXCHORUS_PHASE:
 598             eax_call.set_value<EaxChorusEffectException>(eax_.lPhase);
 599             break;
 600
 601         case EAXCHORUS_RATE:
 602             eax_call.set_value<EaxChorusEffectException>(eax_.flRate);
 603             break;
 604
 605         case EAXCHORUS_DEPTH:
 606             eax_call.set_value<EaxChorusEffectException>(eax_.flDepth);
 607             break;
 608
 609         case EAXCHORUS_FEEDBACK:
 610             eax_call.set_value<EaxChorusEffectException>(eax_.flFeedback);
 611             break;
 612
 613         case EAXCHORUS_DELAY:
 614             eax_call.set_value<EaxChorusEffectException>(eax_.flDelay);
 615             break;
 616
 617         default:
 618             throw EaxChorusEffectException{"Unsupported property id."};
 619     }
 620
 621     return false;
 622 }
 623
 624 void EaxChorusEffect::validate_waveform(
 625     unsigned long ulWaveform)
 626 {
 627     eax_validate_range<EaxChorusEffectException>(
 628         "Waveform",
 629         ulWaveform,
 630         EAXCHORUS_MINWAVEFORM,
 631         EAXCHORUS_MAXWAVEFORM);
 632 }
 633
 634 void EaxChorusEffect::validate_phase(
 635     long lPhase)
 636 {
 637     eax_validate_range<EaxChorusEffectException>(
 638         "Phase",
 639         lPhase,
 640         EAXCHORUS_MINPHASE,
 641         EAXCHORUS_MAXPHASE);
 642 }
 643
 644 void EaxChorusEffect::validate_rate(
 645     float flRate)
 646 {
 647     eax_validate_range<EaxChorusEffectException>(
 648         "Rate",
 649         flRate,
 650         EAXCHORUS_MINRATE,
 651         EAXCHORUS_MAXRATE);
 652 }
 653
 654 void EaxChorusEffect::validate_depth(
 655     float flDepth)
 656 {
 657     eax_validate_range<EaxChorusEffectException>(
 658         "Depth",
 659         flDepth,
 660         EAXCHORUS_MINDEPTH,
 661         EAXCHORUS_MAXDEPTH);
 662 }
 663
 664 void EaxChorusEffect::validate_feedback(
 665     float flFeedback)
 666 {
 667     eax_validate_range<EaxChorusEffectException>(
 668         "Feedback",
 669         flFeedback,
 670         EAXCHORUS_MINFEEDBACK,
 671         EAXCHORUS_MAXFEEDBACK);
 672 }
 673
 674 void EaxChorusEffect::validate_delay(
 675     float flDelay)
 676 {
 677     eax_validate_range<EaxChorusEffectException>(
 678         "Delay",
 679         flDelay,
 680         EAXCHORUS_MINDELAY,
 681         EAXCHORUS_MAXDELAY);
 682 }
 683
 684 void EaxChorusEffect::validate_all(
 685     const EAXCHORUSPROPERTIES& eax_all)
 686 {
 687     validate_waveform(eax_all.ulWaveform);
 688     validate_phase(eax_all.lPhase);
 689     validate_rate(eax_all.flRate);
 690     validate_depth(eax_all.flDepth);
 691     validate_feedback(eax_all.flFeedback);
 692     validate_delay(eax_all.flDelay);
 693 }
 694
 695 void EaxChorusEffect::defer_waveform(
 696     unsigned long ulWaveform)
 697 {
 698     eax_d_.ulWaveform = ulWaveform;
 699     eax_dirty_flags_.ulWaveform = (eax_.ulWaveform != eax_d_.ulWaveform);
 700 }
 701
 702 void EaxChorusEffect::defer_phase(
 703     long lPhase)
 704 {
 705     eax_d_.lPhase = lPhase;
 706     eax_dirty_flags_.lPhase = (eax_.lPhase != eax_d_.lPhase);
 707 }
 708
 709 void EaxChorusEffect::defer_rate(
 710     float flRate)
 711 {
 712     eax_d_.flRate = flRate;
 713     eax_dirty_flags_.flRate = (eax_.flRate != eax_d_.flRate);
 714 }
 715
 716 void EaxChorusEffect::defer_depth(
 717     float flDepth)
 718 {
 719     eax_d_.flDepth = flDepth;
 720     eax_dirty_flags_.flDepth = (eax_.flDepth != eax_d_.flDepth);
 721 }
 722
 723 void EaxChorusEffect::defer_feedback(
 724     float flFeedback)
 725 {
 726     eax_d_.flFeedback = flFeedback;
 727     eax_dirty_flags_.flFeedback = (eax_.flFeedback != eax_d_.flFeedback);
 728 }
 729
 730 void EaxChorusEffect::defer_delay(
 731     float flDelay)
 732 {
 733     eax_d_.flDelay = flDelay;
 734     eax_dirty_flags_.flDelay = (eax_.flDelay != eax_d_.flDelay);
 735 }
 736
 737 void EaxChorusEffect::defer_all(
 738     const EAXCHORUSPROPERTIES& eax_all)
 739 {
 740     defer_waveform(eax_all.ulWaveform);
 741     defer_phase(eax_all.lPhase);
 742     defer_rate(eax_all.flRate);
 743     defer_depth(eax_all.flDepth);
 744     defer_feedback(eax_all.flFeedback);
 745     defer_delay(eax_all.flDelay);
 746 }
 747
 748 void EaxChorusEffect::defer_waveform(
 749     const EaxEaxCall& eax_call)
 750 {
 751     const auto& waveform =
 752         eax_call.get_value<EaxChorusEffectException, const decltype(EAXCHORUSPROPERTIES::ulWaveform)>();
 753
 754     validate_waveform(waveform);
 755     defer_waveform(waveform);
 756 }
 757
 758 void EaxChorusEffect::defer_phase(
 759     const EaxEaxCall& eax_call)
 760 {
 761     const auto& phase =
 762         eax_call.get_value<EaxChorusEffectException, const decltype(EAXCHORUSPROPERTIES::lPhase)>();
 763
 764     validate_phase(phase);
 765     defer_phase(phase);
 766 }
 767
 768 void EaxChorusEffect::defer_rate(
 769     const EaxEaxCall& eax_call)
 770 {
 771     const auto& rate =
 772         eax_call.get_value<EaxChorusEffectException, const decltype(EAXCHORUSPROPERTIES::flRate)>();
 773
 774     validate_rate(rate);
 775     defer_rate(rate);
 776 }
 777
 778 void EaxChorusEffect::defer_depth(
 779     const EaxEaxCall& eax_call)
 780 {
 781     const auto& depth =
 782         eax_call.get_value<EaxChorusEffectException, const decltype(EAXCHORUSPROPERTIES::flDepth)>();
 783
 784     validate_depth(depth);
 785     defer_depth(depth);
 786 }
 787
 788 void EaxChorusEffect::defer_feedback(
 789     const EaxEaxCall& eax_call)
 790 {
 791     const auto& feedback =
 792         eax_call.get_value<EaxChorusEffectException, const decltype(EAXCHORUSPROPERTIES::flFeedback)>();
 793
 794     validate_feedback(feedback);
 795     defer_feedback(feedback);
 796 }
 797
 798 void EaxChorusEffect::defer_delay(
 799     const EaxEaxCall& eax_call)
 800 {
 801     const auto& delay =
 802         eax_call.get_value<EaxChorusEffectException, const decltype(EAXCHORUSPROPERTIES::flDelay)>();
 803
 804     validate_delay(delay);
 805     defer_delay(delay);
 806 }
 807
 808 void EaxChorusEffect::defer_all(
 809     const EaxEaxCall& eax_call)
 810 {
 811     const auto& all =
 812         eax_call.get_value<EaxChorusEffectException, const EAXCHORUSPROPERTIES>();
 813
 814     validate_all(all);
 815     defer_all(all);
 816 }
 817
 818 // [[nodiscard]]
 819 bool EaxChorusEffect::apply_deferred()
 820 {
 821     if (eax_dirty_flags_ == EaxChorusEffectDirtyFlags{})
 822     {
 823         return false;
 824     }
 825
 826     eax_ = eax_d_;
 827
 828     if (eax_dirty_flags_.ulWaveform)
 829     {
 830         set_efx_waveform();
 831     }
 832
 833     if (eax_dirty_flags_.lPhase)
 834     {
 835         set_efx_phase();
 836     }
 837
 838     if (eax_dirty_flags_.flRate)
 839     {
 840         set_efx_rate();
 841     }
 842
 843     if (eax_dirty_flags_.flDepth)
 844     {
 845         set_efx_depth();
 846     }
 847
 848     if (eax_dirty_flags_.flFeedback)
 849     {
 850         set_efx_feedback();
 851     }
 852
 853     if (eax_dirty_flags_.flDelay)
 854     {
 855         set_efx_delay();
 856     }
 857
 858     eax_dirty_flags_ = EaxChorusEffectDirtyFlags{};
 859
 860     return true;
 861 }
 862
 863 // [[nodiscard]]
 864 bool EaxChorusEffect::set(
 865     const EaxEaxCall& eax_call)
 866 {
 867     switch (eax_call.get_property_id())
 868     {
 869         case EAXCHORUS_NONE:
 870             break;
 871
 872         case EAXCHORUS_ALLPARAMETERS:
 873             defer_all(eax_call);
 874             break;
 875
 876         case EAXCHORUS_WAVEFORM:
 877             defer_waveform(eax_call);
 878             break;
 879
 880         case EAXCHORUS_PHASE:
 881             defer_phase(eax_call);
 882             break;
 883
 884         case EAXCHORUS_RATE:
 885             defer_rate(eax_call);
 886             break;
 887
 888         case EAXCHORUS_DEPTH:
 889             defer_depth(eax_call);
 890             break;
 891
 892         case EAXCHORUS_FEEDBACK:
 893             defer_feedback(eax_call);
 894             break;
 895
 896         case EAXCHORUS_DELAY:
 897             defer_delay(eax_call);
 898             break;
 899
 900         default:
 901             throw EaxChorusEffectException{"Unsupported property id."};
 902     }
 903
 904     if (!eax_call.is_deferred())
 905     {
 906         return apply_deferred();
 907     }
 908
 909     return false;
 910 }
 911
 912
 913 } // namespace
 914
 915
 916 EaxEffectUPtr eax_create_eax_chorus_effect()
 917 {
 918     return std::make_unique<::EaxChorusEffect>();
 919 }
 920
 921
 922 namespace
 923 {
 924
 925
 926 using EaxFlangerEffectDirtyFlagsValue = std::uint_least8_t;
 927
 928 struct EaxFlangerEffectDirtyFlags
 929 {
 930     using EaxIsBitFieldStruct = bool;
 931
 932     EaxFlangerEffectDirtyFlagsValue ulWaveform : 1;
 933     EaxFlangerEffectDirtyFlagsValue lPhase : 1;
 934     EaxFlangerEffectDirtyFlagsValue flRate : 1;
 935     EaxFlangerEffectDirtyFlagsValue flDepth : 1;
 936     EaxFlangerEffectDirtyFlagsValue flFeedback : 1;
 937     EaxFlangerEffectDirtyFlagsValue flDelay : 1;
 938 }; // EaxFlangerEffectDirtyFlags
 939
 940
 941 class EaxFlangerEffect final :
 942     public EaxEffect
 943 {
 944 public:
 945     EaxFlangerEffect();
 946
 947
 948     // [[nodiscard]]
 949     bool dispatch(
 950         const EaxEaxCall& eax_call) override;
 951
 952
 953 private:
 954     EAXFLANGERPROPERTIES eax_{};
 955     EAXFLANGERPROPERTIES eax_d_{};
 956     EaxFlangerEffectDirtyFlags eax_dirty_flags_{};
 957
 958
 959     void set_eax_defaults();
 960
 961
 962     void set_efx_waveform();
 963
 964     void set_efx_phase();
 965
 966     void set_efx_rate();
 967
 968     void set_efx_depth();
 969
 970     void set_efx_feedback();
 971
 972     void set_efx_delay();
 973
 974     void set_efx_defaults();
 975
 976
 977     // [[nodiscard]]
 978     bool get(
 979         const EaxEaxCall& eax_call);
 980
 981
 982     void validate_waveform(
 983         unsigned long ulWaveform);
 984
 985     void validate_phase(
 986         long lPhase);
 987
 988     void validate_rate(
 989         float flRate);
 990
 991     void validate_depth(
 992         float flDepth);
 993
 994     void validate_feedback(
 995         float flFeedback);
 996
 997     void validate_delay(
 998         float flDelay);
 999
1000     void validate_all(
1001         const EAXFLANGERPROPERTIES& all);
1002
1003
1004     void defer_waveform(
1005         unsigned long ulWaveform);
1006
1007     void defer_phase(
1008         long lPhase);
1009
1010     void defer_rate(
1011         float flRate);
1012
1013     void defer_depth(
1014         float flDepth);
1015
1016     void defer_feedback(
1017         float flFeedback);
1018
1019     void defer_delay(
1020         float flDelay);
1021
1022     void defer_all(
1023         const EAXFLANGERPROPERTIES& all);
1024
1025
1026     void defer_waveform(
1027         const EaxEaxCall& eax_call);
1028
1029     void defer_phase(
1030         const EaxEaxCall& eax_call);
1031
1032     void defer_rate(
1033         const EaxEaxCall& eax_call);
1034
1035     void defer_depth(
1036         const EaxEaxCall& eax_call);
1037
1038     void defer_feedback(
1039         const EaxEaxCall& eax_call);
1040
1041     void defer_delay(
1042         const EaxEaxCall& eax_call);
1043
1044     void defer_all(
1045         const EaxEaxCall& eax_call);
1046
1047
1048     // [[nodiscard]]
1049     bool apply_deferred();
1050
1051     // [[nodiscard]]
1052     bool set(
1053         const EaxEaxCall& eax_call);
1054 }; // EaxFlangerEffect
1055
1056
1057 class EaxFlangerEffectException :
1058     public EaxException
1059 {
1060 public:
1061     explicit EaxFlangerEffectException(
1062         const char* message)
1063         :
1064         EaxException{"EAX_FLANGER_EFFECT", message}
1065     {
1066     }
1067 }; // EaxFlangerEffectException
1068
1069
1070 EaxFlangerEffect::EaxFlangerEffect()
1071     : EaxEffect{AL_EFFECT_FLANGER}
1072 {
1073     set_eax_defaults();
1074     set_efx_defaults();
1075 }
1076
1077 // [[nodiscard]]
1078 bool EaxFlangerEffect::dispatch(
1079     const EaxEaxCall& eax_call)
1080 {
1081     return eax_call.is_get() ? get(eax_call) : set(eax_call);
1082 }
1083
1084 void EaxFlangerEffect::set_eax_defaults()
1085 {
1086     eax_.ulWaveform = EAXFLANGER_DEFAULTWAVEFORM;
1087     eax_.lPhase = EAXFLANGER_DEFAULTPHASE;
1088     eax_.flRate = EAXFLANGER_DEFAULTRATE;
1089     eax_.flDepth = EAXFLANGER_DEFAULTDEPTH;
1090     eax_.flFeedback = EAXFLANGER_DEFAULTFEEDBACK;
1091     eax_.flDelay = EAXFLANGER_DEFAULTDELAY;
1092
1093     eax_d_ = eax_;
1094 }
1095
1096 void EaxFlangerEffect::set_efx_waveform()
1097 {
1098     const auto waveform = clamp(
1099         static_cast<ALint>(eax_.ulWaveform),
1100         AL_FLANGER_MIN_WAVEFORM,
1101         AL_FLANGER_MAX_WAVEFORM);
1102
1103     eax_set_efx_waveform(waveform, al_effect_props_);
1104 }
1105
1106 void EaxFlangerEffect::set_efx_phase()
1107 {
1108     const auto phase = clamp(
1109         static_cast<ALint>(eax_.lPhase),
1110         AL_FLANGER_MIN_PHASE,
1111         AL_FLANGER_MAX_PHASE);
1112
1113     eax_set_efx_phase(phase, al_effect_props_);
1114 }
1115
1116 void EaxFlangerEffect::set_efx_rate()
1117 {
1118     const auto rate = clamp(
1119         eax_.flRate,
1120         AL_FLANGER_MIN_RATE,
1121         AL_FLANGER_MAX_RATE);
1122
1123     eax_set_efx_rate(rate, al_effect_props_);
1124 }
1125
1126 void EaxFlangerEffect::set_efx_depth()
1127 {
1128     const auto depth = clamp(
1129         eax_.flDepth,
1130         AL_FLANGER_MIN_DEPTH,
1131         AL_FLANGER_MAX_DEPTH);
1132
1133     eax_set_efx_depth(depth, al_effect_props_);
1134 }
1135
1136 void EaxFlangerEffect::set_efx_feedback()
1137 {
1138     const auto feedback = clamp(
1139         eax_.flFeedback,
1140         AL_FLANGER_MIN_FEEDBACK,
1141         AL_FLANGER_MAX_FEEDBACK);
1142
1143     eax_set_efx_feedback(feedback, al_effect_props_);
1144 }
1145
1146 void EaxFlangerEffect::set_efx_delay()
1147 {
1148     const auto delay = clamp(
1149         eax_.flDelay,
1150         AL_FLANGER_MIN_DELAY,
1151         AL_FLANGER_MAX_DELAY);
1152
1153     eax_set_efx_delay(delay, al_effect_props_);
1154 }
1155
1156 void EaxFlangerEffect::set_efx_defaults()
1157 {
1158     set_efx_waveform();
1159     set_efx_phase();
1160     set_efx_rate();
1161     set_efx_depth();
1162     set_efx_feedback();
1163     set_efx_delay();
1164 }
1165
1166 // [[nodiscard]]
1167 bool EaxFlangerEffect::get(
1168     const EaxEaxCall& eax_call)
1169 {
1170     switch (eax_call.get_property_id())
1171     {
1172         case EAXFLANGER_NONE:
1173             break;
1174
1175         case EAXFLANGER_ALLPARAMETERS:
1176             eax_call.set_value<EaxFlangerEffectException>(eax_);
1177             break;
1178
1179         case EAXFLANGER_WAVEFORM:
1180             eax_call.set_value<EaxFlangerEffectException>(eax_.ulWaveform);
1181             break;
1182
1183         case EAXFLANGER_PHASE:
1184             eax_call.set_value<EaxFlangerEffectException>(eax_.lPhase);
1185             break;
1186
1187         case EAXFLANGER_RATE:
1188             eax_call.set_value<EaxFlangerEffectException>(eax_.flRate);
1189             break;
1190
1191         case EAXFLANGER_DEPTH:
1192             eax_call.set_value<EaxFlangerEffectException>(eax_.flDepth);
1193             break;
1194
1195         case EAXFLANGER_FEEDBACK:
1196             eax_call.set_value<EaxFlangerEffectException>(eax_.flFeedback);
1197             break;
1198
1199         case EAXFLANGER_DELAY:
1200             eax_call.set_value<EaxFlangerEffectException>(eax_.flDelay);
1201             break;
1202
1203         default:
1204             throw EaxFlangerEffectException{"Unsupported property id."};
1205     }
1206
1207     return false;
1208 }
1209
1210 void EaxFlangerEffect::validate_waveform(
1211     unsigned long ulWaveform)
1212 {
1213     eax_validate_range<EaxFlangerEffectException>(
1214         "Waveform",
1215         ulWaveform,
1216         EAXFLANGER_MINWAVEFORM,
1217         EAXFLANGER_MAXWAVEFORM);
1218 }
1219
1220 void EaxFlangerEffect::validate_phase(
1221     long lPhase)
1222 {
1223     eax_validate_range<EaxFlangerEffectException>(
1224         "Phase",
1225         lPhase,
1226         EAXFLANGER_MINPHASE,
1227         EAXFLANGER_MAXPHASE);
1228 }
1229
1230 void EaxFlangerEffect::validate_rate(
1231     float flRate)
1232 {
1233     eax_validate_range<EaxFlangerEffectException>(
1234         "Rate",
1235         flRate,
1236         EAXFLANGER_MINRATE,
1237         EAXFLANGER_MAXRATE);
1238 }
1239
1240 void EaxFlangerEffect::validate_depth(
1241     float flDepth)
1242 {
1243     eax_validate_range<EaxFlangerEffectException>(
1244         "Depth",
1245         flDepth,
1246         EAXFLANGER_MINDEPTH,
1247         EAXFLANGER_MAXDEPTH);
1248 }
1249
1250 void EaxFlangerEffect::validate_feedback(
1251     float flFeedback)
1252 {
1253     eax_validate_range<EaxFlangerEffectException>(
1254         "Feedback",
1255         flFeedback,
1256         EAXFLANGER_MINFEEDBACK,
1257         EAXFLANGER_MAXFEEDBACK);
1258 }
1259
1260 void EaxFlangerEffect::validate_delay(
1261     float flDelay)
1262 {
1263     eax_validate_range<EaxFlangerEffectException>(
1264         "Delay",
1265         flDelay,
1266         EAXFLANGER_MINDELAY,
1267         EAXFLANGER_MAXDELAY);
1268 }
1269
1270 void EaxFlangerEffect::validate_all(
1271     const EAXFLANGERPROPERTIES& all)
1272 {
1273     validate_waveform(all.ulWaveform);
1274     validate_phase(all.lPhase);
1275     validate_rate(all.flRate);
1276     validate_depth(all.flDepth);
1277     validate_feedback(all.flDelay);
1278     validate_delay(all.flDelay);
1279 }
1280
1281 void EaxFlangerEffect::defer_waveform(
1282     unsigned long ulWaveform)
1283 {
1284     eax_d_.ulWaveform = ulWaveform;
1285     eax_dirty_flags_.ulWaveform = (eax_.ulWaveform != eax_d_.ulWaveform);
1286 }
1287
1288 void EaxFlangerEffect::defer_phase(
1289     long lPhase)
1290 {
1291     eax_d_.lPhase = lPhase;
1292     eax_dirty_flags_.lPhase = (eax_.lPhase != eax_d_.lPhase);
1293 }
1294
1295 void EaxFlangerEffect::defer_rate(
1296     float flRate)
1297 {
1298     eax_d_.flRate = flRate;
1299     eax_dirty_flags_.flRate = (eax_.flRate != eax_d_.flRate);
1300 }
1301
1302 void EaxFlangerEffect::defer_depth(
1303     float flDepth)
1304 {
1305     eax_d_.flDepth = flDepth;
1306     eax_dirty_flags_.flDepth = (eax_.flDepth != eax_d_.flDepth);
1307 }
1308
1309 void EaxFlangerEffect::defer_feedback(
1310     float flFeedback)
1311 {
1312     eax_d_.flFeedback = flFeedback;
1313     eax_dirty_flags_.flFeedback = (eax_.flFeedback != eax_d_.flFeedback);
1314 }
1315
1316 void EaxFlangerEffect::defer_delay(
1317     float flDelay)
1318 {
1319     eax_d_.flDelay = flDelay;
1320     eax_dirty_flags_.flDelay = (eax_.flDelay != eax_d_.flDelay);
1321 }
1322
1323 void EaxFlangerEffect::defer_all(
1324     const EAXFLANGERPROPERTIES& all)
1325 {
1326     defer_waveform(all.ulWaveform);
1327     defer_phase(all.lPhase);
1328     defer_rate(all.flRate);
1329     defer_depth(all.flDepth);
1330     defer_feedback(all.flDelay);
1331     defer_delay(all.flDelay);
1332 }
1333
1334 void EaxFlangerEffect::defer_waveform(
1335     const EaxEaxCall& eax_call)
1336 {
1337     const auto& waveform =
1338         eax_call.get_value<EaxFlangerEffectException, const decltype(EAXFLANGERPROPERTIES::ulWaveform)>();
1339
1340     validate_waveform(waveform);
1341     defer_waveform(waveform);
1342 }
1343
1344 void EaxFlangerEffect::defer_phase(
1345     const EaxEaxCall& eax_call)
1346 {
1347     const auto& phase =
1348         eax_call.get_value<EaxFlangerEffectException, const decltype(EAXFLANGERPROPERTIES::lPhase)>();
1349
1350     validate_phase(phase);
1351     defer_phase(phase);
1352 }
1353
1354 void EaxFlangerEffect::defer_rate(
1355     const EaxEaxCall& eax_call)
1356 {
1357     const auto& rate =
1358         eax_call.get_value<EaxFlangerEffectException, const decltype(EAXFLANGERPROPERTIES::flRate)>();
1359
1360     validate_rate(rate);
1361     defer_rate(rate);
1362 }
1363
1364 void EaxFlangerEffect::defer_depth(
1365     const EaxEaxCall& eax_call)
1366 {
1367     const auto& depth =
1368         eax_call.get_value<EaxFlangerEffectException, const decltype(EAXFLANGERPROPERTIES::flDepth)>();
1369
1370     validate_depth(depth);
1371     defer_depth(depth);
1372 }
1373
1374 void EaxFlangerEffect::defer_feedback(
1375     const EaxEaxCall& eax_call)
1376 {
1377     const auto& feedback =
1378         eax_call.get_value<EaxFlangerEffectException, const decltype(EAXFLANGERPROPERTIES::flFeedback)>();
1379
1380     validate_feedback(feedback);
1381     defer_feedback(feedback);
1382 }
1383
1384 void EaxFlangerEffect::defer_delay(
1385     const EaxEaxCall& eax_call)
1386 {
1387     const auto& delay =
1388         eax_call.get_value<EaxFlangerEffectException, const decltype(EAXFLANGERPROPERTIES::flDelay)>();
1389
1390     validate_delay(delay);
1391     defer_delay(delay);
1392 }
1393
1394 void EaxFlangerEffect::defer_all(
1395     const EaxEaxCall& eax_call)
1396 {
1397     const auto& all =
1398         eax_call.get_value<EaxFlangerEffectException, const EAXFLANGERPROPERTIES>();
1399
1400     validate_all(all);
1401     defer_all(all);
1402 }
1403
1404 // [[nodiscard]]
1405 bool EaxFlangerEffect::apply_deferred()
1406 {
1407     if (eax_dirty_flags_ == EaxFlangerEffectDirtyFlags{})
1408     {
1409         return false;
1410     }
1411
1412     eax_ = eax_d_;
1413
1414     if (eax_dirty_flags_.ulWaveform)
1415     {
1416         set_efx_waveform();
1417     }
1418
1419     if (eax_dirty_flags_.lPhase)
1420     {
1421         set_efx_phase();
1422     }
1423
1424     if (eax_dirty_flags_.flRate)
1425     {
1426         set_efx_rate();
1427     }
1428
1429     if (eax_dirty_flags_.flDepth)
1430     {
1431         set_efx_depth();
1432     }
1433
1434     if (eax_dirty_flags_.flFeedback)
1435     {
1436         set_efx_feedback();
1437     }
1438
1439     if (eax_dirty_flags_.flDelay)
1440     {
1441         set_efx_delay();
1442     }
1443
1444     eax_dirty_flags_ = EaxFlangerEffectDirtyFlags{};
1445
1446     return true;
1447 }
1448
1449 // [[nodiscard]]
1450 bool EaxFlangerEffect::set(
1451     const EaxEaxCall& eax_call)
1452 {
1453     switch (eax_call.get_property_id())
1454     {
1455         case EAXFLANGER_NONE:
1456             break;
1457
1458         case EAXFLANGER_ALLPARAMETERS:
1459             defer_all(eax_call);
1460             break;
1461
1462         case EAXFLANGER_WAVEFORM:
1463             defer_waveform(eax_call);
1464             break;
1465
1466         case EAXFLANGER_PHASE:
1467             defer_phase(eax_call);
1468             break;
1469
1470         case EAXFLANGER_RATE:
1471             defer_rate(eax_call);
1472             break;
1473
1474         case EAXFLANGER_DEPTH:
1475             defer_depth(eax_call);
1476             break;
1477
1478         case EAXFLANGER_FEEDBACK:
1479             defer_feedback(eax_call);
1480             break;
1481
1482         case EAXFLANGER_DELAY:
1483             defer_delay(eax_call);
1484             break;
1485
1486         default:
1487             throw EaxFlangerEffectException{"Unsupported property id."};
1488     }
1489
1490     if (!eax_call.is_deferred())
1491     {
1492         return apply_deferred();
1493     }
1494
1495     return false;
1496 }
1497
1498 } // namespace
1499
1500 EaxEffectUPtr eax_create_eax_flanger_effect()
1501 {
1502     return std::make_unique<EaxFlangerEffect>();
1503 }
1504
1505 #endif // ALSOFT_EAX