al/effects/modulator.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 "effects.h"
  12
  13 #ifdef ALSOFT_EAX
  14 #include <cassert>
  15
  16 #include "alnumeric.h"
  17
  18 #include "al/eax_exception.h"
  19 #include "al/eax_utils.h"
  20 #endif // ALSOFT_EAX
  21
  22
  23 namespace {
  24
  25 al::optional<ModulatorWaveform> WaveformFromEmum(ALenum value)
  26 {
  27     switch(value)
  28     {
  29     case AL_RING_MODULATOR_SINUSOID: return al::make_optional(ModulatorWaveform::Sinusoid);
  30     case AL_RING_MODULATOR_SAWTOOTH: return al::make_optional(ModulatorWaveform::Sawtooth);
  31     case AL_RING_MODULATOR_SQUARE: return al::make_optional(ModulatorWaveform::Square);
  32     }
  33     return al::nullopt;
  34 }
  35 ALenum EnumFromWaveform(ModulatorWaveform type)
  36 {
  37     switch(type)
  38     {
  39     case ModulatorWaveform::Sinusoid: return AL_RING_MODULATOR_SINUSOID;
  40     case ModulatorWaveform::Sawtooth: return AL_RING_MODULATOR_SAWTOOTH;
  41     case ModulatorWaveform::Square: return AL_RING_MODULATOR_SQUARE;
  42     }
  43     throw std::runtime_error{"Invalid modulator waveform: " +
  44         std::to_string(static_cast<int>(type))};
  45 }
  46
  47 void Modulator_setParamf(EffectProps *props, ALenum param, float val)
  48 {
  49     switch(param)
  50     {
  51     case AL_RING_MODULATOR_FREQUENCY:
  52         if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
  53             throw effect_exception{AL_INVALID_VALUE, "Modulator frequency out of range: %f", val};
  54         props->Modulator.Frequency = val;
  55         break;
  56
  57     case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
  58         if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF))
  59             throw effect_exception{AL_INVALID_VALUE, "Modulator high-pass cutoff out of range: %f", val};
  60         props->Modulator.HighPassCutoff = val;
  61         break;
  62
  63     default:
  64         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param};
  65     }
  66 }
  67 void Modulator_setParamfv(EffectProps *props, ALenum param, const float *vals)
  68 { Modulator_setParamf(props, param, vals[0]); }
  69 void Modulator_setParami(EffectProps *props, ALenum param, int val)
  70 {
  71     switch(param)
  72     {
  73     case AL_RING_MODULATOR_FREQUENCY:
  74     case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
  75         Modulator_setParamf(props, param, static_cast<float>(val));
  76         break;
  77
  78     case AL_RING_MODULATOR_WAVEFORM:
  79         if(auto formopt = WaveformFromEmum(val))
  80             props->Modulator.Waveform = *formopt;
  81         else
  82             throw effect_exception{AL_INVALID_VALUE, "Invalid modulator waveform: 0x%04x", val};
  83         break;
  84
  85     default:
  86         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x",
  87             param};
  88     }
  89 }
  90 void Modulator_setParamiv(EffectProps *props, ALenum param, const int *vals)
  91 { Modulator_setParami(props, param, vals[0]); }
  92
  93 void Modulator_getParami(const EffectProps *props, ALenum param, int *val)
  94 {
  95     switch(param)
  96     {
  97     case AL_RING_MODULATOR_FREQUENCY:
  98         *val = static_cast<int>(props->Modulator.Frequency);
  99         break;
 100     case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 101         *val = static_cast<int>(props->Modulator.HighPassCutoff);
 102         break;
 103     case AL_RING_MODULATOR_WAVEFORM:
 104         *val = EnumFromWaveform(props->Modulator.Waveform);
 105         break;
 106
 107     default:
 108         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x",
 109             param};
 110     }
 111 }
 112 void Modulator_getParamiv(const EffectProps *props, ALenum param, int *vals)
 113 { Modulator_getParami(props, param, vals); }
 114 void Modulator_getParamf(const EffectProps *props, ALenum param, float *val)
 115 {
 116     switch(param)
 117     {
 118     case AL_RING_MODULATOR_FREQUENCY:
 119         *val = props->Modulator.Frequency;
 120         break;
 121     case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
 122         *val = props->Modulator.HighPassCutoff;
 123         break;
 124
 125     default:
 126         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param};
 127     }
 128 }
 129 void Modulator_getParamfv(const EffectProps *props, ALenum param, float *vals)
 130 { Modulator_getParamf(props, param, vals); }
 131
 132 EffectProps genDefaultProps() noexcept
 133 {
 134     EffectProps props{};
 135     props.Modulator.Frequency      = AL_RING_MODULATOR_DEFAULT_FREQUENCY;
 136     props.Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF;
 137     props.Modulator.Waveform       = *WaveformFromEmum(AL_RING_MODULATOR_DEFAULT_WAVEFORM);
 138     return props;
 139 }
 140
 141 } // namespace
 142
 143 DEFINE_ALEFFECT_VTABLE(Modulator);
 144
 145 const EffectProps ModulatorEffectProps{genDefaultProps()};
 146
 147 #ifdef ALSOFT_EAX
 148 namespace {
 149
 150 using EaxRingModulatorEffectDirtyFlagsValue = std::uint_least8_t;
 151
 152 struct EaxRingModulatorEffectDirtyFlags
 153 {
 154     using EaxIsBitFieldStruct = bool;
 155
 156     EaxRingModulatorEffectDirtyFlagsValue flFrequency : 1;
 157     EaxRingModulatorEffectDirtyFlagsValue flHighPassCutOff : 1;
 158     EaxRingModulatorEffectDirtyFlagsValue ulWaveform : 1;
 159 }; // EaxPitchShifterEffectDirtyFlags
 160
 161
 162 class EaxRingModulatorEffect final :
 163     public EaxEffect
 164 {
 165 public:
 166     EaxRingModulatorEffect();
 167
 168
 169     // [[nodiscard]]
 170     bool dispatch(
 171         const EaxEaxCall& eax_call) override;
 172
 173
 174 private:
 175     EAXRINGMODULATORPROPERTIES eax_{};
 176     EAXRINGMODULATORPROPERTIES eax_d_{};
 177     EaxRingModulatorEffectDirtyFlags eax_dirty_flags_{};
 178
 179
 180     void set_eax_defaults();
 181
 182
 183     void set_efx_frequency();
 184
 185     void set_efx_high_pass_cutoff();
 186
 187     void set_efx_waveform();
 188
 189     void set_efx_defaults();
 190
 191
 192     // [[nodiscard]]
 193     bool get(
 194         const EaxEaxCall& eax_call);
 195
 196
 197     void validate_frequency(
 198         float flFrequency);
 199
 200     void validate_high_pass_cutoff(
 201         float flHighPassCutOff);
 202
 203     void validate_waveform(
 204         unsigned long ulWaveform);
 205
 206     void validate_all(
 207         const EAXRINGMODULATORPROPERTIES& all);
 208
 209
 210     void defer_frequency(
 211         float flFrequency);
 212
 213     void defer_high_pass_cutoff(
 214         float flHighPassCutOff);
 215
 216     void defer_waveform(
 217         unsigned long ulWaveform);
 218
 219     void defer_all(
 220         const EAXRINGMODULATORPROPERTIES& all);
 221
 222
 223     void defer_frequency(
 224         const EaxEaxCall& eax_call);
 225
 226     void defer_high_pass_cutoff(
 227         const EaxEaxCall& eax_call);
 228
 229     void defer_waveform(
 230         const EaxEaxCall& eax_call);
 231
 232     void defer_all(
 233         const EaxEaxCall& eax_call);
 234
 235
 236     // [[nodiscard]]
 237     bool apply_deferred();
 238
 239     // [[nodiscard]]
 240     bool set(
 241         const EaxEaxCall& eax_call);
 242 }; // EaxRingModulatorEffect
 243
 244
 245 class EaxRingModulatorEffectException :
 246     public EaxException
 247 {
 248 public:
 249     explicit EaxRingModulatorEffectException(
 250         const char* message)
 251         :
 252         EaxException{"EAX_RING_MODULATOR_EFFECT", message}
 253     {
 254     }
 255 }; // EaxRingModulatorEffectException
 256
 257
 258 EaxRingModulatorEffect::EaxRingModulatorEffect()
 259     : EaxEffect{AL_EFFECT_RING_MODULATOR}
 260 {
 261     set_eax_defaults();
 262     set_efx_defaults();
 263 }
 264
 265 // [[nodiscard]]
 266 bool EaxRingModulatorEffect::dispatch(
 267     const EaxEaxCall& eax_call)
 268 {
 269     return eax_call.is_get() ? get(eax_call) : set(eax_call);
 270 }
 271
 272 void EaxRingModulatorEffect::set_eax_defaults()
 273 {
 274     eax_.flFrequency = EAXRINGMODULATOR_DEFAULTFREQUENCY;
 275     eax_.flHighPassCutOff = EAXRINGMODULATOR_DEFAULTHIGHPASSCUTOFF;
 276     eax_.ulWaveform = EAXRINGMODULATOR_DEFAULTWAVEFORM;
 277
 278     eax_d_ = eax_;
 279 }
 280
 281 void EaxRingModulatorEffect::set_efx_frequency()
 282 {
 283     const auto frequency = clamp(
 284         eax_.flFrequency,
 285         AL_RING_MODULATOR_MIN_FREQUENCY,
 286         AL_RING_MODULATOR_MAX_FREQUENCY);
 287
 288     al_effect_props_.Modulator.Frequency = frequency;
 289 }
 290
 291 void EaxRingModulatorEffect::set_efx_high_pass_cutoff()
 292 {
 293     const auto high_pass_cutoff = clamp(
 294         eax_.flHighPassCutOff,
 295         AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF,
 296         AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF);
 297
 298     al_effect_props_.Modulator.HighPassCutoff = high_pass_cutoff;
 299 }
 300
 301 void EaxRingModulatorEffect::set_efx_waveform()
 302 {
 303     const auto waveform = clamp(
 304         static_cast<ALint>(eax_.ulWaveform),
 305         AL_RING_MODULATOR_MIN_WAVEFORM,
 306         AL_RING_MODULATOR_MAX_WAVEFORM);
 307
 308     const auto efx_waveform = WaveformFromEmum(waveform);
 309     assert(efx_waveform.has_value());
 310     al_effect_props_.Modulator.Waveform = *efx_waveform;
 311 }
 312
 313 void EaxRingModulatorEffect::set_efx_defaults()
 314 {
 315     set_efx_frequency();
 316     set_efx_high_pass_cutoff();
 317     set_efx_waveform();
 318 }
 319
 320 // [[nodiscard]]
 321 bool EaxRingModulatorEffect::get(
 322     const EaxEaxCall& eax_call)
 323 {
 324     switch (eax_call.get_property_id())
 325     {
 326         case EAXRINGMODULATOR_NONE:
 327             break;
 328
 329         case EAXRINGMODULATOR_ALLPARAMETERS:
 330             eax_call.set_value<EaxRingModulatorEffectException>(eax_);
 331             break;
 332
 333         case EAXRINGMODULATOR_FREQUENCY:
 334             eax_call.set_value<EaxRingModulatorEffectException>(eax_.flFrequency);
 335             break;
 336
 337         case EAXRINGMODULATOR_HIGHPASSCUTOFF:
 338             eax_call.set_value<EaxRingModulatorEffectException>(eax_.flHighPassCutOff);
 339             break;
 340
 341         case EAXRINGMODULATOR_WAVEFORM:
 342             eax_call.set_value<EaxRingModulatorEffectException>(eax_.ulWaveform);
 343             break;
 344
 345         default:
 346             throw EaxRingModulatorEffectException{"Unsupported property id."};
 347     }
 348
 349     return false;
 350 }
 351
 352 void EaxRingModulatorEffect::validate_frequency(
 353     float flFrequency)
 354 {
 355     eax_validate_range<EaxRingModulatorEffectException>(
 356         "Frequency",
 357         flFrequency,
 358         EAXRINGMODULATOR_MINFREQUENCY,
 359         EAXRINGMODULATOR_MAXFREQUENCY);
 360 }
 361
 362 void EaxRingModulatorEffect::validate_high_pass_cutoff(
 363     float flHighPassCutOff)
 364 {
 365     eax_validate_range<EaxRingModulatorEffectException>(
 366         "High-Pass Cutoff",
 367         flHighPassCutOff,
 368         EAXRINGMODULATOR_MINHIGHPASSCUTOFF,
 369         EAXRINGMODULATOR_MAXHIGHPASSCUTOFF);
 370 }
 371
 372 void EaxRingModulatorEffect::validate_waveform(
 373     unsigned long ulWaveform)
 374 {
 375     eax_validate_range<EaxRingModulatorEffectException>(
 376         "Waveform",
 377         ulWaveform,
 378         EAXRINGMODULATOR_MINWAVEFORM,
 379         EAXRINGMODULATOR_MAXWAVEFORM);
 380 }
 381
 382 void EaxRingModulatorEffect::validate_all(
 383     const EAXRINGMODULATORPROPERTIES& all)
 384 {
 385     validate_frequency(all.flFrequency);
 386     validate_high_pass_cutoff(all.flHighPassCutOff);
 387     validate_waveform(all.ulWaveform);
 388 }
 389
 390 void EaxRingModulatorEffect::defer_frequency(
 391     float flFrequency)
 392 {
 393     eax_d_.flFrequency = flFrequency;
 394     eax_dirty_flags_.flFrequency = (eax_.flFrequency != eax_d_.flFrequency);
 395 }
 396
 397 void EaxRingModulatorEffect::defer_high_pass_cutoff(
 398     float flHighPassCutOff)
 399 {
 400     eax_d_.flHighPassCutOff = flHighPassCutOff;
 401     eax_dirty_flags_.flHighPassCutOff = (eax_.flHighPassCutOff != eax_d_.flHighPassCutOff);
 402 }
 403
 404 void EaxRingModulatorEffect::defer_waveform(
 405     unsigned long ulWaveform)
 406 {
 407     eax_d_.ulWaveform = ulWaveform;
 408     eax_dirty_flags_.ulWaveform = (eax_.ulWaveform != eax_d_.ulWaveform);
 409 }
 410
 411 void EaxRingModulatorEffect::defer_all(
 412     const EAXRINGMODULATORPROPERTIES& all)
 413 {
 414     defer_frequency(all.flFrequency);
 415     defer_high_pass_cutoff(all.flHighPassCutOff);
 416     defer_waveform(all.ulWaveform);
 417 }
 418
 419 void EaxRingModulatorEffect::defer_frequency(
 420     const EaxEaxCall& eax_call)
 421 {
 422     const auto& frequency =
 423         eax_call.get_value<
 424         EaxRingModulatorEffectException, const decltype(EAXRINGMODULATORPROPERTIES::flFrequency)>();
 425
 426     validate_frequency(frequency);
 427     defer_frequency(frequency);
 428 }
 429
 430 void EaxRingModulatorEffect::defer_high_pass_cutoff(
 431     const EaxEaxCall& eax_call)
 432 {
 433     const auto& high_pass_cutoff =
 434         eax_call.get_value<
 435         EaxRingModulatorEffectException, const decltype(EAXRINGMODULATORPROPERTIES::flHighPassCutOff)>();
 436
 437     validate_high_pass_cutoff(high_pass_cutoff);
 438     defer_high_pass_cutoff(high_pass_cutoff);
 439 }
 440
 441 void EaxRingModulatorEffect::defer_waveform(
 442     const EaxEaxCall& eax_call)
 443 {
 444     const auto& waveform =
 445         eax_call.get_value<
 446         EaxRingModulatorEffectException, const decltype(EAXRINGMODULATORPROPERTIES::ulWaveform)>();
 447
 448     validate_waveform(waveform);
 449     defer_waveform(waveform);
 450 }
 451
 452 void EaxRingModulatorEffect::defer_all(
 453     const EaxEaxCall& eax_call)
 454 {
 455     const auto& all =
 456         eax_call.get_value<EaxRingModulatorEffectException, const EAXRINGMODULATORPROPERTIES>();
 457
 458     validate_all(all);
 459     defer_all(all);
 460 }
 461
 462 // [[nodiscard]]
 463 bool EaxRingModulatorEffect::apply_deferred()
 464 {
 465     if (eax_dirty_flags_ == EaxRingModulatorEffectDirtyFlags{})
 466     {
 467         return false;
 468     }
 469
 470     eax_ = eax_d_;
 471
 472     if (eax_dirty_flags_.flFrequency)
 473     {
 474         set_efx_frequency();
 475     }
 476
 477     if (eax_dirty_flags_.flHighPassCutOff)
 478     {
 479         set_efx_high_pass_cutoff();
 480     }
 481
 482     if (eax_dirty_flags_.ulWaveform)
 483     {
 484         set_efx_waveform();
 485     }
 486
 487     eax_dirty_flags_ = EaxRingModulatorEffectDirtyFlags{};
 488
 489     return true;
 490 }
 491
 492 // [[nodiscard]]
 493 bool EaxRingModulatorEffect::set(
 494     const EaxEaxCall& eax_call)
 495 {
 496     switch (eax_call.get_property_id())
 497     {
 498         case EAXRINGMODULATOR_NONE:
 499             break;
 500
 501         case EAXRINGMODULATOR_ALLPARAMETERS:
 502             defer_all(eax_call);
 503             break;
 504
 505         case EAXRINGMODULATOR_FREQUENCY:
 506             defer_frequency(eax_call);
 507             break;
 508
 509         case EAXRINGMODULATOR_HIGHPASSCUTOFF:
 510             defer_high_pass_cutoff(eax_call);
 511             break;
 512
 513         case EAXRINGMODULATOR_WAVEFORM:
 514             defer_waveform(eax_call);
 515             break;
 516
 517         default:
 518             throw EaxRingModulatorEffectException{"Unsupported property id."};
 519     }
 520
 521     if (!eax_call.is_deferred())
 522     {
 523         return apply_deferred();
 524     }
 525
 526     return false;
 527 }
 528
 529 } // namespace
 530
 531 EaxEffectUPtr eax_create_eax_ring_modulator_effect()
 532 {
 533     return std::make_unique<EaxRingModulatorEffect>();
 534 }
 535
 536 #endif // ALSOFT_EAX