al/effects/echo.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 static_assert(EchoMaxDelay >= AL_ECHO_MAX_DELAY, "Echo max delay too short");
  21 static_assert(EchoMaxLRDelay >= AL_ECHO_MAX_LRDELAY, "Echo max left-right delay too short");
  22
  23 void Echo_setParami(EffectProps*, ALenum param, int)
  24 { throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param}; }
  25 void Echo_setParamiv(EffectProps*, ALenum param, const int*)
  26 { throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param}; }
  27 void Echo_setParamf(EffectProps *props, ALenum param, float val)
  28 {
  29     switch(param)
  30     {
  31     case AL_ECHO_DELAY:
  32         if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY))
  33             throw effect_exception{AL_INVALID_VALUE, "Echo delay out of range"};
  34         props->Echo.Delay = val;
  35         break;
  36
  37     case AL_ECHO_LRDELAY:
  38         if(!(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY))
  39             throw effect_exception{AL_INVALID_VALUE, "Echo LR delay out of range"};
  40         props->Echo.LRDelay = val;
  41         break;
  42
  43     case AL_ECHO_DAMPING:
  44         if(!(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING))
  45             throw effect_exception{AL_INVALID_VALUE, "Echo damping out of range"};
  46         props->Echo.Damping = val;
  47         break;
  48
  49     case AL_ECHO_FEEDBACK:
  50         if(!(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK))
  51             throw effect_exception{AL_INVALID_VALUE, "Echo feedback out of range"};
  52         props->Echo.Feedback = val;
  53         break;
  54
  55     case AL_ECHO_SPREAD:
  56         if(!(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD))
  57             throw effect_exception{AL_INVALID_VALUE, "Echo spread out of range"};
  58         props->Echo.Spread = val;
  59         break;
  60
  61     default:
  62         throw effect_exception{AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param};
  63     }
  64 }
  65 void Echo_setParamfv(EffectProps *props, ALenum param, const float *vals)
  66 { Echo_setParamf(props, param, vals[0]); }
  67
  68 void Echo_getParami(const EffectProps*, ALenum param, int*)
  69 { throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer property 0x%04x", param}; }
  70 void Echo_getParamiv(const EffectProps*, ALenum param, int*)
  71 { throw effect_exception{AL_INVALID_ENUM, "Invalid echo integer-vector property 0x%04x", param}; }
  72 void Echo_getParamf(const EffectProps *props, ALenum param, float *val)
  73 {
  74     switch(param)
  75     {
  76     case AL_ECHO_DELAY:
  77         *val = props->Echo.Delay;
  78         break;
  79
  80     case AL_ECHO_LRDELAY:
  81         *val = props->Echo.LRDelay;
  82         break;
  83
  84     case AL_ECHO_DAMPING:
  85         *val = props->Echo.Damping;
  86         break;
  87
  88     case AL_ECHO_FEEDBACK:
  89         *val = props->Echo.Feedback;
  90         break;
  91
  92     case AL_ECHO_SPREAD:
  93         *val = props->Echo.Spread;
  94         break;
  95
  96     default:
  97         throw effect_exception{AL_INVALID_ENUM, "Invalid echo float property 0x%04x", param};
  98     }
  99 }
 100 void Echo_getParamfv(const EffectProps *props, ALenum param, float *vals)
 101 { Echo_getParamf(props, param, vals); }
 102
 103 EffectProps genDefaultProps() noexcept
 104 {
 105     EffectProps props{};
 106     props.Echo.Delay    = AL_ECHO_DEFAULT_DELAY;
 107     props.Echo.LRDelay  = AL_ECHO_DEFAULT_LRDELAY;
 108     props.Echo.Damping  = AL_ECHO_DEFAULT_DAMPING;
 109     props.Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK;
 110     props.Echo.Spread   = AL_ECHO_DEFAULT_SPREAD;
 111     return props;
 112 }
 113
 114 } // namespace
 115
 116 DEFINE_ALEFFECT_VTABLE(Echo);
 117
 118 const EffectProps EchoEffectProps{genDefaultProps()};
 119
 120 #ifdef ALSOFT_EAX
 121 namespace {
 122
 123 using EaxEchoEffectDirtyFlagsValue = std::uint_least8_t;
 124
 125 struct EaxEchoEffectDirtyFlags
 126 {
 127     using EaxIsBitFieldStruct = bool;
 128
 129     EaxEchoEffectDirtyFlagsValue flDelay : 1;
 130     EaxEchoEffectDirtyFlagsValue flLRDelay : 1;
 131     EaxEchoEffectDirtyFlagsValue flDamping : 1;
 132     EaxEchoEffectDirtyFlagsValue flFeedback : 1;
 133     EaxEchoEffectDirtyFlagsValue flSpread : 1;
 134 }; // EaxEchoEffectDirtyFlags
 135
 136
 137 class EaxEchoEffect final :
 138     public EaxEffect
 139 {
 140 public:
 141     EaxEchoEffect();
 142
 143
 144     // [[nodiscard]]
 145     bool dispatch(
 146         const EaxEaxCall& eax_call) override;
 147
 148
 149 private:
 150     EAXECHOPROPERTIES eax_{};
 151     EAXECHOPROPERTIES eax_d_{};
 152     EaxEchoEffectDirtyFlags eax_dirty_flags_{};
 153
 154
 155     void set_eax_defaults();
 156
 157
 158     void set_efx_delay();
 159
 160     void set_efx_lr_delay();
 161
 162     void set_efx_damping();
 163
 164     void set_efx_feedback();
 165
 166     void set_efx_spread();
 167
 168     void set_efx_defaults();
 169
 170
 171     // [[nodiscard]]
 172     bool get(
 173         const EaxEaxCall& eax_call);
 174
 175
 176     void validate_delay(
 177         float flDelay);
 178
 179     void validate_lr_delay(
 180         float flLRDelay);
 181
 182     void validate_damping(
 183         float flDamping);
 184
 185     void validate_feedback(
 186         float flFeedback);
 187
 188     void validate_spread(
 189         float flSpread);
 190
 191     void validate_all(
 192         const EAXECHOPROPERTIES& all);
 193
 194
 195     void defer_delay(
 196         float flDelay);
 197
 198     void defer_lr_delay(
 199         float flLRDelay);
 200
 201     void defer_damping(
 202         float flDamping);
 203
 204     void defer_feedback(
 205         float flFeedback);
 206
 207     void defer_spread(
 208         float flSpread);
 209
 210     void defer_all(
 211         const EAXECHOPROPERTIES& all);
 212
 213
 214     void defer_delay(
 215         const EaxEaxCall& eax_call);
 216
 217     void defer_lr_delay(
 218         const EaxEaxCall& eax_call);
 219
 220     void defer_damping(
 221         const EaxEaxCall& eax_call);
 222
 223     void defer_feedback(
 224         const EaxEaxCall& eax_call);
 225
 226     void defer_spread(
 227         const EaxEaxCall& eax_call);
 228
 229     void defer_all(
 230         const EaxEaxCall& eax_call);
 231
 232
 233     bool apply_deferred();
 234
 235     bool set(
 236         const EaxEaxCall& eax_call);
 237 }; // EaxEchoEffect
 238
 239
 240 class EaxEchoEffectException :
 241     public EaxException
 242 {
 243 public:
 244     explicit EaxEchoEffectException(
 245         const char* message)
 246         :
 247         EaxException{"EAX_ECHO_EFFECT", message}
 248     {
 249     }
 250 }; // EaxEchoEffectException
 251
 252
 253 EaxEchoEffect::EaxEchoEffect()
 254     : EaxEffect{AL_EFFECT_ECHO}
 255 {
 256     set_eax_defaults();
 257     set_efx_defaults();
 258 }
 259
 260 // [[nodiscard]]
 261 bool EaxEchoEffect::dispatch(
 262     const EaxEaxCall& eax_call)
 263 {
 264     return eax_call.is_get() ? get(eax_call) : set(eax_call);
 265 }
 266
 267 void EaxEchoEffect::set_eax_defaults()
 268 {
 269     eax_.flDelay = EAXECHO_DEFAULTDELAY;
 270     eax_.flLRDelay = EAXECHO_DEFAULTLRDELAY;
 271     eax_.flDamping = EAXECHO_DEFAULTDAMPING;
 272     eax_.flFeedback = EAXECHO_DEFAULTFEEDBACK;
 273     eax_.flSpread = EAXECHO_DEFAULTSPREAD;
 274
 275     eax_d_ = eax_;
 276 }
 277
 278 void EaxEchoEffect::set_efx_delay()
 279 {
 280     const auto delay = clamp(
 281         eax_.flDelay,
 282         AL_ECHO_MIN_DELAY,
 283         AL_ECHO_MAX_DELAY);
 284
 285     al_effect_props_.Echo.Delay = delay;
 286 }
 287
 288 void EaxEchoEffect::set_efx_lr_delay()
 289 {
 290     const auto lr_delay = clamp(
 291         eax_.flLRDelay,
 292         AL_ECHO_MIN_LRDELAY,
 293         AL_ECHO_MAX_LRDELAY);
 294
 295     al_effect_props_.Echo.LRDelay = lr_delay;
 296 }
 297
 298 void EaxEchoEffect::set_efx_damping()
 299 {
 300     const auto damping = clamp(
 301         eax_.flDamping,
 302         AL_ECHO_MIN_DAMPING,
 303         AL_ECHO_MAX_DAMPING);
 304
 305     al_effect_props_.Echo.Damping = damping;
 306 }
 307
 308 void EaxEchoEffect::set_efx_feedback()
 309 {
 310     const auto feedback = clamp(
 311         eax_.flFeedback,
 312         AL_ECHO_MIN_FEEDBACK,
 313         AL_ECHO_MAX_FEEDBACK);
 314
 315     al_effect_props_.Echo.Feedback = feedback;
 316 }
 317
 318 void EaxEchoEffect::set_efx_spread()
 319 {
 320     const auto spread = clamp(
 321         eax_.flSpread,
 322         AL_ECHO_MIN_SPREAD,
 323         AL_ECHO_MAX_SPREAD);
 324
 325     al_effect_props_.Echo.Spread = spread;
 326 }
 327
 328 void EaxEchoEffect::set_efx_defaults()
 329 {
 330     set_efx_delay();
 331     set_efx_lr_delay();
 332     set_efx_damping();
 333     set_efx_feedback();
 334     set_efx_spread();
 335 }
 336
 337 // [[nodiscard]]
 338 bool EaxEchoEffect::get(
 339     const EaxEaxCall& eax_call)
 340 {
 341     switch (eax_call.get_property_id())
 342     {
 343         case EAXECHO_NONE:
 344             break;
 345
 346         case EAXECHO_ALLPARAMETERS:
 347             eax_call.set_value<EaxEchoEffectException>(eax_);
 348             break;
 349
 350         case EAXECHO_DELAY:
 351             eax_call.set_value<EaxEchoEffectException>(eax_.flDelay);
 352             break;
 353
 354         case EAXECHO_LRDELAY:
 355             eax_call.set_value<EaxEchoEffectException>(eax_.flLRDelay);
 356             break;
 357
 358         case EAXECHO_DAMPING:
 359             eax_call.set_value<EaxEchoEffectException>(eax_.flDamping);
 360             break;
 361
 362         case EAXECHO_FEEDBACK:
 363             eax_call.set_value<EaxEchoEffectException>(eax_.flFeedback);
 364             break;
 365
 366         case EAXECHO_SPREAD:
 367             eax_call.set_value<EaxEchoEffectException>(eax_.flSpread);
 368             break;
 369
 370         default:
 371             throw EaxEchoEffectException{"Unsupported property id."};
 372     }
 373
 374     return false;
 375 }
 376
 377 void EaxEchoEffect::validate_delay(
 378     float flDelay)
 379 {
 380     eax_validate_range<EaxEchoEffectException>(
 381         "Delay",
 382         flDelay,
 383         EAXECHO_MINDELAY,
 384         EAXECHO_MAXDELAY);
 385 }
 386
 387 void EaxEchoEffect::validate_lr_delay(
 388     float flLRDelay)
 389 {
 390     eax_validate_range<EaxEchoEffectException>(
 391         "LR Delay",
 392         flLRDelay,
 393         EAXECHO_MINLRDELAY,
 394         EAXECHO_MAXLRDELAY);
 395 }
 396
 397 void EaxEchoEffect::validate_damping(
 398     float flDamping)
 399 {
 400     eax_validate_range<EaxEchoEffectException>(
 401         "Damping",
 402         flDamping,
 403         EAXECHO_MINDAMPING,
 404         EAXECHO_MAXDAMPING);
 405 }
 406
 407 void EaxEchoEffect::validate_feedback(
 408     float flFeedback)
 409 {
 410     eax_validate_range<EaxEchoEffectException>(
 411         "Feedback",
 412         flFeedback,
 413         EAXECHO_MINFEEDBACK,
 414         EAXECHO_MAXFEEDBACK);
 415 }
 416
 417 void EaxEchoEffect::validate_spread(
 418     float flSpread)
 419 {
 420     eax_validate_range<EaxEchoEffectException>(
 421         "Spread",
 422         flSpread,
 423         EAXECHO_MINSPREAD,
 424         EAXECHO_MAXSPREAD);
 425 }
 426
 427 void EaxEchoEffect::validate_all(
 428     const EAXECHOPROPERTIES& all)
 429 {
 430     validate_delay(all.flDelay);
 431     validate_lr_delay(all.flLRDelay);
 432     validate_damping(all.flDamping);
 433     validate_feedback(all.flFeedback);
 434     validate_spread(all.flSpread);
 435 }
 436
 437 void EaxEchoEffect::defer_delay(
 438     float flDelay)
 439 {
 440     eax_d_.flDelay = flDelay;
 441     eax_dirty_flags_.flDelay = (eax_.flDelay != eax_d_.flDelay);
 442 }
 443
 444 void EaxEchoEffect::defer_lr_delay(
 445     float flLRDelay)
 446 {
 447     eax_d_.flLRDelay = flLRDelay;
 448     eax_dirty_flags_.flLRDelay = (eax_.flLRDelay != eax_d_.flLRDelay);
 449 }
 450
 451 void EaxEchoEffect::defer_damping(
 452     float flDamping)
 453 {
 454     eax_d_.flDamping = flDamping;
 455     eax_dirty_flags_.flDamping = (eax_.flDamping != eax_d_.flDamping);
 456 }
 457
 458 void EaxEchoEffect::defer_feedback(
 459     float flFeedback)
 460 {
 461     eax_d_.flFeedback = flFeedback;
 462     eax_dirty_flags_.flFeedback = (eax_.flFeedback != eax_d_.flFeedback);
 463 }
 464
 465 void EaxEchoEffect::defer_spread(
 466     float flSpread)
 467 {
 468     eax_d_.flSpread = flSpread;
 469     eax_dirty_flags_.flSpread = (eax_.flSpread != eax_d_.flSpread);
 470 }
 471
 472 void EaxEchoEffect::defer_all(
 473     const EAXECHOPROPERTIES& all)
 474 {
 475     defer_delay(all.flDelay);
 476     defer_lr_delay(all.flLRDelay);
 477     defer_damping(all.flDamping);
 478     defer_feedback(all.flFeedback);
 479     defer_spread(all.flSpread);
 480 }
 481
 482 void EaxEchoEffect::defer_delay(
 483     const EaxEaxCall& eax_call)
 484 {
 485     const auto& delay =
 486         eax_call.get_value<EaxEchoEffectException, const decltype(EAXECHOPROPERTIES::flDelay)>();
 487
 488     validate_delay(delay);
 489     defer_delay(delay);
 490 }
 491
 492 void EaxEchoEffect::defer_lr_delay(
 493     const EaxEaxCall& eax_call)
 494 {
 495     const auto& lr_delay =
 496         eax_call.get_value<EaxEchoEffectException, const decltype(EAXECHOPROPERTIES::flLRDelay)>();
 497
 498     validate_lr_delay(lr_delay);
 499     defer_lr_delay(lr_delay);
 500 }
 501
 502 void EaxEchoEffect::defer_damping(
 503     const EaxEaxCall& eax_call)
 504 {
 505     const auto& damping =
 506         eax_call.get_value<EaxEchoEffectException, const decltype(EAXECHOPROPERTIES::flDamping)>();
 507
 508     validate_damping(damping);
 509     defer_damping(damping);
 510 }
 511
 512 void EaxEchoEffect::defer_feedback(
 513     const EaxEaxCall& eax_call)
 514 {
 515     const auto& feedback =
 516         eax_call.get_value<EaxEchoEffectException, const decltype(EAXECHOPROPERTIES::flFeedback)>();
 517
 518     validate_feedback(feedback);
 519     defer_feedback(feedback);
 520 }
 521
 522 void EaxEchoEffect::defer_spread(
 523     const EaxEaxCall& eax_call)
 524 {
 525     const auto& spread =
 526         eax_call.get_value<EaxEchoEffectException, const decltype(EAXECHOPROPERTIES::flSpread)>();
 527
 528     validate_spread(spread);
 529     defer_spread(spread);
 530 }
 531
 532 void EaxEchoEffect::defer_all(
 533     const EaxEaxCall& eax_call)
 534 {
 535     const auto& all =
 536         eax_call.get_value<EaxEchoEffectException, const EAXECHOPROPERTIES>();
 537
 538     validate_all(all);
 539     defer_all(all);
 540 }
 541
 542 // [[nodiscard]]
 543 bool EaxEchoEffect::apply_deferred()
 544 {
 545     if (eax_dirty_flags_ == EaxEchoEffectDirtyFlags{})
 546     {
 547         return false;
 548     }
 549
 550     eax_ = eax_d_;
 551
 552     if (eax_dirty_flags_.flDelay)
 553     {
 554         set_efx_delay();
 555     }
 556
 557     if (eax_dirty_flags_.flLRDelay)
 558     {
 559         set_efx_lr_delay();
 560     }
 561
 562     if (eax_dirty_flags_.flDamping)
 563     {
 564         set_efx_damping();
 565     }
 566
 567     if (eax_dirty_flags_.flFeedback)
 568     {
 569         set_efx_feedback();
 570     }
 571
 572     if (eax_dirty_flags_.flSpread)
 573     {
 574         set_efx_spread();
 575     }
 576
 577     eax_dirty_flags_ = EaxEchoEffectDirtyFlags{};
 578
 579     return true;
 580 }
 581
 582 // [[nodiscard]]
 583 bool EaxEchoEffect::set(
 584     const EaxEaxCall& eax_call)
 585 {
 586     switch (eax_call.get_property_id())
 587     {
 588         case EAXECHO_NONE:
 589             break;
 590
 591         case EAXECHO_ALLPARAMETERS:
 592             defer_all(eax_call);
 593             break;
 594
 595         case EAXECHO_DELAY:
 596             defer_delay(eax_call);
 597             break;
 598
 599         case EAXECHO_LRDELAY:
 600             defer_lr_delay(eax_call);
 601             break;
 602
 603         case EAXECHO_DAMPING:
 604             defer_damping(eax_call);
 605             break;
 606
 607         case EAXECHO_FEEDBACK:
 608             defer_feedback(eax_call);
 609             break;
 610
 611         case EAXECHO_SPREAD:
 612             defer_spread(eax_call);
 613             break;
 614
 615         default:
 616             throw EaxEchoEffectException{"Unsupported property id."};
 617     }
 618
 619     if (!eax_call.is_deferred())
 620     {
 621         return apply_deferred();
 622     }
 623
 624     return false;
 625 }
 626
 627 } // namespace
 628
 629 EaxEffectUPtr eax_create_eax_echo_effect()
 630 {
 631     return std::make_unique<EaxEchoEffect>();
 632 }
 633
 634 #endif // ALSOFT_EAX