al/effects/autowah.cpp

   1
   2 #include "config.h"
   3
   4 #include <cmath>
   5 #include <cstdlib>
   6
   7 #include <algorithm>
   8
   9 #include "AL/efx.h"
  10
  11 #include "alc/effects/base.h"
  12 #include "effects.h"
  13
  14 #ifdef ALSOFT_EAX
  15 #include "alnumeric.h"
  16
  17 #include "al/eax_exception.h"
  18 #include "al/eax_utils.h"
  19 #endif // ALSOFT_EAX
  20
  21
  22 namespace {
  23
  24 void Autowah_setParamf(EffectProps *props, ALenum param, float val)
  25 {
  26     switch(param)
  27     {
  28     case AL_AUTOWAH_ATTACK_TIME:
  29         if(!(val >= AL_AUTOWAH_MIN_ATTACK_TIME && val <= AL_AUTOWAH_MAX_ATTACK_TIME))
  30             throw effect_exception{AL_INVALID_VALUE, "Autowah attack time out of range"};
  31         props->Autowah.AttackTime = val;
  32         break;
  33
  34     case AL_AUTOWAH_RELEASE_TIME:
  35         if(!(val >= AL_AUTOWAH_MIN_RELEASE_TIME && val <= AL_AUTOWAH_MAX_RELEASE_TIME))
  36             throw effect_exception{AL_INVALID_VALUE, "Autowah release time out of range"};
  37         props->Autowah.ReleaseTime = val;
  38         break;
  39
  40     case AL_AUTOWAH_RESONANCE:
  41         if(!(val >= AL_AUTOWAH_MIN_RESONANCE && val <= AL_AUTOWAH_MAX_RESONANCE))
  42             throw effect_exception{AL_INVALID_VALUE, "Autowah resonance out of range"};
  43         props->Autowah.Resonance = val;
  44         break;
  45
  46     case AL_AUTOWAH_PEAK_GAIN:
  47         if(!(val >= AL_AUTOWAH_MIN_PEAK_GAIN && val <= AL_AUTOWAH_MAX_PEAK_GAIN))
  48             throw effect_exception{AL_INVALID_VALUE, "Autowah peak gain out of range"};
  49         props->Autowah.PeakGain = val;
  50         break;
  51
  52     default:
  53         throw effect_exception{AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param};
  54     }
  55 }
  56 void Autowah_setParamfv(EffectProps *props,  ALenum param, const float *vals)
  57 { Autowah_setParamf(props, param, vals[0]); }
  58
  59 void Autowah_setParami(EffectProps*, ALenum param, int)
  60 { throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param}; }
  61 void Autowah_setParamiv(EffectProps*, ALenum param, const int*)
  62 {
  63     throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x",
  64         param};
  65 }
  66
  67 void Autowah_getParamf(const EffectProps *props, ALenum param, float *val)
  68 {
  69     switch(param)
  70     {
  71     case AL_AUTOWAH_ATTACK_TIME:
  72         *val = props->Autowah.AttackTime;
  73         break;
  74
  75     case AL_AUTOWAH_RELEASE_TIME:
  76         *val = props->Autowah.ReleaseTime;
  77         break;
  78
  79     case AL_AUTOWAH_RESONANCE:
  80         *val = props->Autowah.Resonance;
  81         break;
  82
  83     case AL_AUTOWAH_PEAK_GAIN:
  84         *val = props->Autowah.PeakGain;
  85         break;
  86
  87     default:
  88         throw effect_exception{AL_INVALID_ENUM, "Invalid autowah float property 0x%04x", param};
  89     }
  90
  91 }
  92 void Autowah_getParamfv(const EffectProps *props, ALenum param, float *vals)
  93 { Autowah_getParamf(props, param, vals); }
  94
  95 void Autowah_getParami(const EffectProps*, ALenum param, int*)
  96 { throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer property 0x%04x", param}; }
  97 void Autowah_getParamiv(const EffectProps*, ALenum param, int*)
  98 {
  99     throw effect_exception{AL_INVALID_ENUM, "Invalid autowah integer vector property 0x%04x",
 100         param};
 101 }
 102
 103 EffectProps genDefaultProps() noexcept
 104 {
 105     EffectProps props{};
 106     props.Autowah.AttackTime = AL_AUTOWAH_DEFAULT_ATTACK_TIME;
 107     props.Autowah.ReleaseTime = AL_AUTOWAH_DEFAULT_RELEASE_TIME;
 108     props.Autowah.Resonance = AL_AUTOWAH_DEFAULT_RESONANCE;
 109     props.Autowah.PeakGain = AL_AUTOWAH_DEFAULT_PEAK_GAIN;
 110     return props;
 111 }
 112
 113 } // namespace
 114
 115 DEFINE_ALEFFECT_VTABLE(Autowah);
 116
 117 const EffectProps AutowahEffectProps{genDefaultProps()};
 118
 119 #ifdef ALSOFT_EAX
 120 namespace {
 121
 122 using EaxAutoWahEffectDirtyFlagsValue = std::uint_least8_t;
 123
 124 struct EaxAutoWahEffectDirtyFlags
 125 {
 126     using EaxIsBitFieldStruct = bool;
 127
 128     EaxAutoWahEffectDirtyFlagsValue flAttackTime : 1;
 129     EaxAutoWahEffectDirtyFlagsValue flReleaseTime : 1;
 130     EaxAutoWahEffectDirtyFlagsValue lResonance : 1;
 131     EaxAutoWahEffectDirtyFlagsValue lPeakLevel : 1;
 132 }; // EaxAutoWahEffectDirtyFlags
 133
 134
 135 class EaxAutoWahEffect final :
 136     public EaxEffect
 137 {
 138 public:
 139     EaxAutoWahEffect();
 140
 141
 142     // [[nodiscard]]
 143     bool dispatch(
 144         const EaxEaxCall& eax_call) override;
 145
 146
 147 private:
 148     EAXAUTOWAHPROPERTIES eax_{};
 149     EAXAUTOWAHPROPERTIES eax_d_{};
 150     EaxAutoWahEffectDirtyFlags eax_dirty_flags_{};
 151
 152
 153     void set_eax_defaults();
 154
 155
 156     void set_efx_attack_time();
 157
 158     void set_efx_release_time();
 159
 160     void set_efx_resonance();
 161
 162     void set_efx_peak_gain();
 163
 164     void set_efx_defaults();
 165
 166
 167     // [[nodiscard]]
 168     bool get(
 169         const EaxEaxCall& eax_call);
 170
 171
 172     void validate_attack_time(
 173         float flAttackTime);
 174
 175     void validate_release_time(
 176         float flReleaseTime);
 177
 178     void validate_resonance(
 179         long lResonance);
 180
 181     void validate_peak_level(
 182         long lPeakLevel);
 183
 184     void validate_all(
 185         const EAXAUTOWAHPROPERTIES& eax_all);
 186
 187
 188     void defer_attack_time(
 189         float flAttackTime);
 190
 191     void defer_release_time(
 192         float flReleaseTime);
 193
 194     void defer_resonance(
 195         long lResonance);
 196
 197     void defer_peak_level(
 198         long lPeakLevel);
 199
 200     void defer_all(
 201         const EAXAUTOWAHPROPERTIES& eax_all);
 202
 203
 204     void defer_attack_time(
 205         const EaxEaxCall& eax_call);
 206
 207     void defer_release_time(
 208         const EaxEaxCall& eax_call);
 209
 210     void defer_resonance(
 211         const EaxEaxCall& eax_call);
 212
 213     void defer_peak_level(
 214         const EaxEaxCall& eax_call);
 215
 216     void defer_all(
 217         const EaxEaxCall& eax_call);
 218
 219     // [[nodiscard]]
 220     bool apply_deferred();
 221
 222     // [[nodiscard]]
 223     bool set(
 224         const EaxEaxCall& eax_call);
 225 }; // EaxAutoWahEffect
 226
 227
 228 class EaxAutoWahEffectException :
 229     public EaxException
 230 {
 231 public:
 232     explicit EaxAutoWahEffectException(
 233         const char* message)
 234         :
 235         EaxException{"EAX_AUTO_WAH_EFFECT", message}
 236     {
 237     }
 238 }; // EaxAutoWahEffectException
 239
 240
 241 EaxAutoWahEffect::EaxAutoWahEffect()
 242     : EaxEffect{AL_EFFECT_AUTOWAH}
 243 {
 244     set_eax_defaults();
 245     set_efx_defaults();
 246 }
 247
 248 // [[nodiscard]]
 249 bool EaxAutoWahEffect::dispatch(
 250     const EaxEaxCall& eax_call)
 251 {
 252     return eax_call.is_get() ? get(eax_call) : set(eax_call);
 253 }
 254
 255 void EaxAutoWahEffect::set_eax_defaults()
 256 {
 257     eax_.flAttackTime = EAXAUTOWAH_DEFAULTATTACKTIME;
 258     eax_.flReleaseTime = EAXAUTOWAH_DEFAULTRELEASETIME;
 259     eax_.lResonance = EAXAUTOWAH_DEFAULTRESONANCE;
 260     eax_.lPeakLevel = EAXAUTOWAH_DEFAULTPEAKLEVEL;
 261
 262     eax_d_ = eax_;
 263 }
 264
 265 void EaxAutoWahEffect::set_efx_attack_time()
 266 {
 267     const auto attack_time = clamp(
 268         eax_.flAttackTime,
 269         AL_AUTOWAH_MIN_ATTACK_TIME,
 270         AL_AUTOWAH_MAX_ATTACK_TIME);
 271
 272     al_effect_props_.Autowah.AttackTime = attack_time;
 273 }
 274
 275 void EaxAutoWahEffect::set_efx_release_time()
 276 {
 277     const auto release_time = clamp(
 278         eax_.flReleaseTime,
 279         AL_AUTOWAH_MIN_RELEASE_TIME,
 280         AL_AUTOWAH_MAX_RELEASE_TIME);
 281
 282     al_effect_props_.Autowah.ReleaseTime = release_time;
 283 }
 284
 285 void EaxAutoWahEffect::set_efx_resonance()
 286 {
 287     const auto resonance = clamp(
 288         level_mb_to_gain(static_cast<float>(eax_.lResonance)),
 289         AL_AUTOWAH_MIN_RESONANCE,
 290         AL_AUTOWAH_MAX_RESONANCE);
 291
 292     al_effect_props_.Autowah.Resonance = resonance;
 293 }
 294
 295 void EaxAutoWahEffect::set_efx_peak_gain()
 296 {
 297     const auto peak_gain = clamp(
 298         level_mb_to_gain(static_cast<float>(eax_.lPeakLevel)),
 299         AL_AUTOWAH_MIN_PEAK_GAIN,
 300         AL_AUTOWAH_MAX_PEAK_GAIN);
 301
 302     al_effect_props_.Autowah.PeakGain = peak_gain;
 303 }
 304
 305 void EaxAutoWahEffect::set_efx_defaults()
 306 {
 307     set_efx_attack_time();
 308     set_efx_release_time();
 309     set_efx_resonance();
 310     set_efx_peak_gain();
 311 }
 312
 313 bool EaxAutoWahEffect::get(
 314     const EaxEaxCall& eax_call)
 315 {
 316     switch (eax_call.get_property_id())
 317     {
 318         case EAXAUTOWAH_NONE:
 319             break;
 320
 321         case EAXAUTOWAH_ALLPARAMETERS:
 322             eax_call.set_value<EaxAutoWahEffectException>(eax_);
 323             break;
 324
 325         case EAXAUTOWAH_ATTACKTIME:
 326             eax_call.set_value<EaxAutoWahEffectException>(eax_.flAttackTime);
 327             break;
 328
 329         case EAXAUTOWAH_RELEASETIME:
 330             eax_call.set_value<EaxAutoWahEffectException>(eax_.flReleaseTime);
 331             break;
 332
 333         case EAXAUTOWAH_RESONANCE:
 334             eax_call.set_value<EaxAutoWahEffectException>(eax_.lResonance);
 335             break;
 336
 337         case EAXAUTOWAH_PEAKLEVEL:
 338             eax_call.set_value<EaxAutoWahEffectException>(eax_.lPeakLevel);
 339             break;
 340
 341         default:
 342             throw EaxAutoWahEffectException{"Unsupported property id."};
 343     }
 344
 345     return false;
 346 }
 347
 348 void EaxAutoWahEffect::validate_attack_time(
 349     float flAttackTime)
 350 {
 351     eax_validate_range<EaxAutoWahEffectException>(
 352         "Attack Time",
 353         flAttackTime,
 354         EAXAUTOWAH_MINATTACKTIME,
 355         EAXAUTOWAH_MAXATTACKTIME);
 356 }
 357
 358 void EaxAutoWahEffect::validate_release_time(
 359     float flReleaseTime)
 360 {
 361     eax_validate_range<EaxAutoWahEffectException>(
 362         "Release Time",
 363         flReleaseTime,
 364         EAXAUTOWAH_MINRELEASETIME,
 365         EAXAUTOWAH_MAXRELEASETIME);
 366 }
 367
 368 void EaxAutoWahEffect::validate_resonance(
 369     long lResonance)
 370 {
 371     eax_validate_range<EaxAutoWahEffectException>(
 372         "Resonance",
 373         lResonance,
 374         EAXAUTOWAH_MINRESONANCE,
 375         EAXAUTOWAH_MAXRESONANCE);
 376 }
 377
 378 void EaxAutoWahEffect::validate_peak_level(
 379     long lPeakLevel)
 380 {
 381     eax_validate_range<EaxAutoWahEffectException>(
 382         "Peak Level",
 383         lPeakLevel,
 384         EAXAUTOWAH_MINPEAKLEVEL,
 385         EAXAUTOWAH_MAXPEAKLEVEL);
 386 }
 387
 388 void EaxAutoWahEffect::validate_all(
 389     const EAXAUTOWAHPROPERTIES& eax_all)
 390 {
 391     validate_attack_time(eax_all.flAttackTime);
 392     validate_release_time(eax_all.flReleaseTime);
 393     validate_resonance(eax_all.lResonance);
 394     validate_peak_level(eax_all.lPeakLevel);
 395 }
 396
 397 void EaxAutoWahEffect::defer_attack_time(
 398     float flAttackTime)
 399 {
 400     eax_d_.flAttackTime = flAttackTime;
 401     eax_dirty_flags_.flAttackTime = (eax_.flAttackTime != eax_d_.flAttackTime);
 402 }
 403
 404 void EaxAutoWahEffect::defer_release_time(
 405     float flReleaseTime)
 406 {
 407     eax_d_.flReleaseTime = flReleaseTime;
 408     eax_dirty_flags_.flReleaseTime = (eax_.flReleaseTime != eax_d_.flReleaseTime);
 409 }
 410
 411 void EaxAutoWahEffect::defer_resonance(
 412     long lResonance)
 413 {
 414     eax_d_.lResonance = lResonance;
 415     eax_dirty_flags_.lResonance = (eax_.lResonance != eax_d_.lResonance);
 416 }
 417
 418 void EaxAutoWahEffect::defer_peak_level(
 419     long lPeakLevel)
 420 {
 421     eax_d_.lPeakLevel = lPeakLevel;
 422     eax_dirty_flags_.lPeakLevel = (eax_.lPeakLevel != eax_d_.lPeakLevel);
 423 }
 424
 425 void EaxAutoWahEffect::defer_all(
 426     const EAXAUTOWAHPROPERTIES& eax_all)
 427 {
 428     validate_all(eax_all);
 429
 430     defer_attack_time(eax_all.flAttackTime);
 431     defer_release_time(eax_all.flReleaseTime);
 432     defer_resonance(eax_all.lResonance);
 433     defer_peak_level(eax_all.lPeakLevel);
 434 }
 435
 436 void EaxAutoWahEffect::defer_attack_time(
 437     const EaxEaxCall& eax_call)
 438 {
 439     const auto& attack_time =
 440         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::flAttackTime)>();
 441
 442     validate_attack_time(attack_time);
 443     defer_attack_time(attack_time);
 444 }
 445
 446 void EaxAutoWahEffect::defer_release_time(
 447     const EaxEaxCall& eax_call)
 448 {
 449     const auto& release_time =
 450         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::flReleaseTime)>();
 451
 452     validate_release_time(release_time);
 453     defer_release_time(release_time);
 454 }
 455
 456 void EaxAutoWahEffect::defer_resonance(
 457     const EaxEaxCall& eax_call)
 458 {
 459     const auto& resonance =
 460         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::lResonance)>();
 461
 462     validate_resonance(resonance);
 463     defer_resonance(resonance);
 464 }
 465
 466 void EaxAutoWahEffect::defer_peak_level(
 467     const EaxEaxCall& eax_call)
 468 {
 469     const auto& peak_level =
 470         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::lPeakLevel)>();
 471
 472     validate_peak_level(peak_level);
 473     defer_peak_level(peak_level);
 474 }
 475
 476 void EaxAutoWahEffect::defer_all(
 477     const EaxEaxCall& eax_call)
 478 {
 479     const auto& all =
 480         eax_call.get_value<EaxAutoWahEffectException, const EAXAUTOWAHPROPERTIES>();
 481
 482     validate_all(all);
 483     defer_all(all);
 484 }
 485
 486 // [[nodiscard]]
 487 bool EaxAutoWahEffect::apply_deferred()
 488 {
 489     if (eax_dirty_flags_ == EaxAutoWahEffectDirtyFlags{})
 490     {
 491         return false;
 492     }
 493
 494     eax_ = eax_d_;
 495
 496     if (eax_dirty_flags_.flAttackTime)
 497     {
 498         set_efx_attack_time();
 499     }
 500
 501     if (eax_dirty_flags_.flReleaseTime)
 502     {
 503         set_efx_release_time();
 504     }
 505
 506     if (eax_dirty_flags_.lResonance)
 507     {
 508         set_efx_resonance();
 509     }
 510
 511     if (eax_dirty_flags_.lPeakLevel)
 512     {
 513         set_efx_peak_gain();
 514     }
 515
 516     eax_dirty_flags_ = EaxAutoWahEffectDirtyFlags{};
 517
 518     return true;
 519 }
 520
 521 // [[nodiscard]]
 522 bool EaxAutoWahEffect::set(
 523     const EaxEaxCall& eax_call)
 524 {
 525     switch (eax_call.get_property_id())
 526     {
 527         case EAXAUTOWAH_NONE:
 528             break;
 529
 530         case EAXAUTOWAH_ALLPARAMETERS:
 531             defer_all(eax_call);
 532             break;
 533
 534         case EAXAUTOWAH_ATTACKTIME:
 535             defer_attack_time(eax_call);
 536             break;
 537
 538         case EAXAUTOWAH_RELEASETIME:
 539             defer_release_time(eax_call);
 540             break;
 541
 542         case EAXAUTOWAH_RESONANCE:
 543             defer_resonance(eax_call);
 544             break;
 545
 546         case EAXAUTOWAH_PEAKLEVEL:
 547             defer_peak_level(eax_call);
 548             break;
 549
 550         default:
 551             throw EaxAutoWahEffectException{"Unsupported property id."};
 552     }
 553
 554     if (!eax_call.is_deferred())
 555     {
 556         return apply_deferred();
 557     }
 558
 559     return false;
 560 }
 561
 562 } // namespace
 563
 564 EaxEffectUPtr eax_create_eax_auto_wah_effect()
 565 {
 566     return std::make_unique<::EaxAutoWahEffect>();
 567 }
 568
 569 #endif // ALSOFT_EAX