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     void dispatch(const EaxEaxCall& eax_call) override;
 143
 144     // [[nodiscard]]
 145     bool apply_deferred() override;
 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     void get(const EaxEaxCall& eax_call);
 168
 169
 170     void validate_attack_time(
 171         float flAttackTime);
 172
 173     void validate_release_time(
 174         float flReleaseTime);
 175
 176     void validate_resonance(
 177         long lResonance);
 178
 179     void validate_peak_level(
 180         long lPeakLevel);
 181
 182     void validate_all(
 183         const EAXAUTOWAHPROPERTIES& eax_all);
 184
 185
 186     void defer_attack_time(
 187         float flAttackTime);
 188
 189     void defer_release_time(
 190         float flReleaseTime);
 191
 192     void defer_resonance(
 193         long lResonance);
 194
 195     void defer_peak_level(
 196         long lPeakLevel);
 197
 198     void defer_all(
 199         const EAXAUTOWAHPROPERTIES& eax_all);
 200
 201
 202     void defer_attack_time(
 203         const EaxEaxCall& eax_call);
 204
 205     void defer_release_time(
 206         const EaxEaxCall& eax_call);
 207
 208     void defer_resonance(
 209         const EaxEaxCall& eax_call);
 210
 211     void defer_peak_level(
 212         const EaxEaxCall& eax_call);
 213
 214     void defer_all(
 215         const EaxEaxCall& eax_call);
 216
 217     void set(const EaxEaxCall& eax_call);
 218 }; // EaxAutoWahEffect
 219
 220
 221 class EaxAutoWahEffectException :
 222     public EaxException
 223 {
 224 public:
 225     explicit EaxAutoWahEffectException(
 226         const char* message)
 227         :
 228         EaxException{"EAX_AUTO_WAH_EFFECT", message}
 229     {
 230     }
 231 }; // EaxAutoWahEffectException
 232
 233
 234 EaxAutoWahEffect::EaxAutoWahEffect()
 235     : EaxEffect{AL_EFFECT_AUTOWAH}
 236 {
 237     set_eax_defaults();
 238     set_efx_defaults();
 239 }
 240
 241 void EaxAutoWahEffect::dispatch(const EaxEaxCall& eax_call)
 242 {
 243     eax_call.is_get() ? get(eax_call) : set(eax_call);
 244 }
 245
 246 void EaxAutoWahEffect::set_eax_defaults()
 247 {
 248     eax_.flAttackTime = EAXAUTOWAH_DEFAULTATTACKTIME;
 249     eax_.flReleaseTime = EAXAUTOWAH_DEFAULTRELEASETIME;
 250     eax_.lResonance = EAXAUTOWAH_DEFAULTRESONANCE;
 251     eax_.lPeakLevel = EAXAUTOWAH_DEFAULTPEAKLEVEL;
 252
 253     eax_d_ = eax_;
 254 }
 255
 256 void EaxAutoWahEffect::set_efx_attack_time()
 257 {
 258     const auto attack_time = clamp(
 259         eax_.flAttackTime,
 260         AL_AUTOWAH_MIN_ATTACK_TIME,
 261         AL_AUTOWAH_MAX_ATTACK_TIME);
 262
 263     al_effect_props_.Autowah.AttackTime = attack_time;
 264 }
 265
 266 void EaxAutoWahEffect::set_efx_release_time()
 267 {
 268     const auto release_time = clamp(
 269         eax_.flReleaseTime,
 270         AL_AUTOWAH_MIN_RELEASE_TIME,
 271         AL_AUTOWAH_MAX_RELEASE_TIME);
 272
 273     al_effect_props_.Autowah.ReleaseTime = release_time;
 274 }
 275
 276 void EaxAutoWahEffect::set_efx_resonance()
 277 {
 278     const auto resonance = clamp(
 279         level_mb_to_gain(static_cast<float>(eax_.lResonance)),
 280         AL_AUTOWAH_MIN_RESONANCE,
 281         AL_AUTOWAH_MAX_RESONANCE);
 282
 283     al_effect_props_.Autowah.Resonance = resonance;
 284 }
 285
 286 void EaxAutoWahEffect::set_efx_peak_gain()
 287 {
 288     const auto peak_gain = clamp(
 289         level_mb_to_gain(static_cast<float>(eax_.lPeakLevel)),
 290         AL_AUTOWAH_MIN_PEAK_GAIN,
 291         AL_AUTOWAH_MAX_PEAK_GAIN);
 292
 293     al_effect_props_.Autowah.PeakGain = peak_gain;
 294 }
 295
 296 void EaxAutoWahEffect::set_efx_defaults()
 297 {
 298     set_efx_attack_time();
 299     set_efx_release_time();
 300     set_efx_resonance();
 301     set_efx_peak_gain();
 302 }
 303
 304 void EaxAutoWahEffect::get(const EaxEaxCall& eax_call)
 305 {
 306     switch (eax_call.get_property_id())
 307     {
 308         case EAXAUTOWAH_NONE:
 309             break;
 310
 311         case EAXAUTOWAH_ALLPARAMETERS:
 312             eax_call.set_value<EaxAutoWahEffectException>(eax_);
 313             break;
 314
 315         case EAXAUTOWAH_ATTACKTIME:
 316             eax_call.set_value<EaxAutoWahEffectException>(eax_.flAttackTime);
 317             break;
 318
 319         case EAXAUTOWAH_RELEASETIME:
 320             eax_call.set_value<EaxAutoWahEffectException>(eax_.flReleaseTime);
 321             break;
 322
 323         case EAXAUTOWAH_RESONANCE:
 324             eax_call.set_value<EaxAutoWahEffectException>(eax_.lResonance);
 325             break;
 326
 327         case EAXAUTOWAH_PEAKLEVEL:
 328             eax_call.set_value<EaxAutoWahEffectException>(eax_.lPeakLevel);
 329             break;
 330
 331         default:
 332             throw EaxAutoWahEffectException{"Unsupported property id."};
 333     }
 334 }
 335
 336 void EaxAutoWahEffect::validate_attack_time(
 337     float flAttackTime)
 338 {
 339     eax_validate_range<EaxAutoWahEffectException>(
 340         "Attack Time",
 341         flAttackTime,
 342         EAXAUTOWAH_MINATTACKTIME,
 343         EAXAUTOWAH_MAXATTACKTIME);
 344 }
 345
 346 void EaxAutoWahEffect::validate_release_time(
 347     float flReleaseTime)
 348 {
 349     eax_validate_range<EaxAutoWahEffectException>(
 350         "Release Time",
 351         flReleaseTime,
 352         EAXAUTOWAH_MINRELEASETIME,
 353         EAXAUTOWAH_MAXRELEASETIME);
 354 }
 355
 356 void EaxAutoWahEffect::validate_resonance(
 357     long lResonance)
 358 {
 359     eax_validate_range<EaxAutoWahEffectException>(
 360         "Resonance",
 361         lResonance,
 362         EAXAUTOWAH_MINRESONANCE,
 363         EAXAUTOWAH_MAXRESONANCE);
 364 }
 365
 366 void EaxAutoWahEffect::validate_peak_level(
 367     long lPeakLevel)
 368 {
 369     eax_validate_range<EaxAutoWahEffectException>(
 370         "Peak Level",
 371         lPeakLevel,
 372         EAXAUTOWAH_MINPEAKLEVEL,
 373         EAXAUTOWAH_MAXPEAKLEVEL);
 374 }
 375
 376 void EaxAutoWahEffect::validate_all(
 377     const EAXAUTOWAHPROPERTIES& eax_all)
 378 {
 379     validate_attack_time(eax_all.flAttackTime);
 380     validate_release_time(eax_all.flReleaseTime);
 381     validate_resonance(eax_all.lResonance);
 382     validate_peak_level(eax_all.lPeakLevel);
 383 }
 384
 385 void EaxAutoWahEffect::defer_attack_time(
 386     float flAttackTime)
 387 {
 388     eax_d_.flAttackTime = flAttackTime;
 389     eax_dirty_flags_.flAttackTime = (eax_.flAttackTime != eax_d_.flAttackTime);
 390 }
 391
 392 void EaxAutoWahEffect::defer_release_time(
 393     float flReleaseTime)
 394 {
 395     eax_d_.flReleaseTime = flReleaseTime;
 396     eax_dirty_flags_.flReleaseTime = (eax_.flReleaseTime != eax_d_.flReleaseTime);
 397 }
 398
 399 void EaxAutoWahEffect::defer_resonance(
 400     long lResonance)
 401 {
 402     eax_d_.lResonance = lResonance;
 403     eax_dirty_flags_.lResonance = (eax_.lResonance != eax_d_.lResonance);
 404 }
 405
 406 void EaxAutoWahEffect::defer_peak_level(
 407     long lPeakLevel)
 408 {
 409     eax_d_.lPeakLevel = lPeakLevel;
 410     eax_dirty_flags_.lPeakLevel = (eax_.lPeakLevel != eax_d_.lPeakLevel);
 411 }
 412
 413 void EaxAutoWahEffect::defer_all(
 414     const EAXAUTOWAHPROPERTIES& eax_all)
 415 {
 416     validate_all(eax_all);
 417
 418     defer_attack_time(eax_all.flAttackTime);
 419     defer_release_time(eax_all.flReleaseTime);
 420     defer_resonance(eax_all.lResonance);
 421     defer_peak_level(eax_all.lPeakLevel);
 422 }
 423
 424 void EaxAutoWahEffect::defer_attack_time(
 425     const EaxEaxCall& eax_call)
 426 {
 427     const auto& attack_time =
 428         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::flAttackTime)>();
 429
 430     validate_attack_time(attack_time);
 431     defer_attack_time(attack_time);
 432 }
 433
 434 void EaxAutoWahEffect::defer_release_time(
 435     const EaxEaxCall& eax_call)
 436 {
 437     const auto& release_time =
 438         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::flReleaseTime)>();
 439
 440     validate_release_time(release_time);
 441     defer_release_time(release_time);
 442 }
 443
 444 void EaxAutoWahEffect::defer_resonance(
 445     const EaxEaxCall& eax_call)
 446 {
 447     const auto& resonance =
 448         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::lResonance)>();
 449
 450     validate_resonance(resonance);
 451     defer_resonance(resonance);
 452 }
 453
 454 void EaxAutoWahEffect::defer_peak_level(
 455     const EaxEaxCall& eax_call)
 456 {
 457     const auto& peak_level =
 458         eax_call.get_value<EaxAutoWahEffectException, const decltype(EAXAUTOWAHPROPERTIES::lPeakLevel)>();
 459
 460     validate_peak_level(peak_level);
 461     defer_peak_level(peak_level);
 462 }
 463
 464 void EaxAutoWahEffect::defer_all(
 465     const EaxEaxCall& eax_call)
 466 {
 467     const auto& all =
 468         eax_call.get_value<EaxAutoWahEffectException, const EAXAUTOWAHPROPERTIES>();
 469
 470     validate_all(all);
 471     defer_all(all);
 472 }
 473
 474 // [[nodiscard]]
 475 bool EaxAutoWahEffect::apply_deferred()
 476 {
 477     if (eax_dirty_flags_ == EaxAutoWahEffectDirtyFlags{})
 478     {
 479         return false;
 480     }
 481
 482     eax_ = eax_d_;
 483
 484     if (eax_dirty_flags_.flAttackTime)
 485     {
 486         set_efx_attack_time();
 487     }
 488
 489     if (eax_dirty_flags_.flReleaseTime)
 490     {
 491         set_efx_release_time();
 492     }
 493
 494     if (eax_dirty_flags_.lResonance)
 495     {
 496         set_efx_resonance();
 497     }
 498
 499     if (eax_dirty_flags_.lPeakLevel)
 500     {
 501         set_efx_peak_gain();
 502     }
 503
 504     eax_dirty_flags_ = EaxAutoWahEffectDirtyFlags{};
 505
 506     return true;
 507 }
 508
 509 void EaxAutoWahEffect::set(const EaxEaxCall& eax_call)
 510 {
 511     switch (eax_call.get_property_id())
 512     {
 513         case EAXAUTOWAH_NONE:
 514             break;
 515
 516         case EAXAUTOWAH_ALLPARAMETERS:
 517             defer_all(eax_call);
 518             break;
 519
 520         case EAXAUTOWAH_ATTACKTIME:
 521             defer_attack_time(eax_call);
 522             break;
 523
 524         case EAXAUTOWAH_RELEASETIME:
 525             defer_release_time(eax_call);
 526             break;
 527
 528         case EAXAUTOWAH_RESONANCE:
 529             defer_resonance(eax_call);
 530             break;
 531
 532         case EAXAUTOWAH_PEAKLEVEL:
 533             defer_peak_level(eax_call);
 534             break;
 535
 536         default:
 537             throw EaxAutoWahEffectException{"Unsupported property id."};
 538     }
 539 }
 540
 541 } // namespace
 542
 543 EaxEffectUPtr eax_create_eax_auto_wah_effect()
 544 {
 545     return std::make_unique<::EaxAutoWahEffect>();
 546 }
 547
 548 #endif // ALSOFT_EAX