al/effects/vmorpher.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<VMorpherPhenome> PhenomeFromEnum(ALenum val)
  26 {
  27 #define HANDLE_PHENOME(x) case AL_VOCAL_MORPHER_PHONEME_ ## x:                \
  28     return al::make_optional(VMorpherPhenome::x)
  29     switch(val)
  30     {
  31     HANDLE_PHENOME(A);
  32     HANDLE_PHENOME(E);
  33     HANDLE_PHENOME(I);
  34     HANDLE_PHENOME(O);
  35     HANDLE_PHENOME(U);
  36     HANDLE_PHENOME(AA);
  37     HANDLE_PHENOME(AE);
  38     HANDLE_PHENOME(AH);
  39     HANDLE_PHENOME(AO);
  40     HANDLE_PHENOME(EH);
  41     HANDLE_PHENOME(ER);
  42     HANDLE_PHENOME(IH);
  43     HANDLE_PHENOME(IY);
  44     HANDLE_PHENOME(UH);
  45     HANDLE_PHENOME(UW);
  46     HANDLE_PHENOME(B);
  47     HANDLE_PHENOME(D);
  48     HANDLE_PHENOME(F);
  49     HANDLE_PHENOME(G);
  50     HANDLE_PHENOME(J);
  51     HANDLE_PHENOME(K);
  52     HANDLE_PHENOME(L);
  53     HANDLE_PHENOME(M);
  54     HANDLE_PHENOME(N);
  55     HANDLE_PHENOME(P);
  56     HANDLE_PHENOME(R);
  57     HANDLE_PHENOME(S);
  58     HANDLE_PHENOME(T);
  59     HANDLE_PHENOME(V);
  60     HANDLE_PHENOME(Z);
  61     }
  62     return al::nullopt;
  63 #undef HANDLE_PHENOME
  64 }
  65 ALenum EnumFromPhenome(VMorpherPhenome phenome)
  66 {
  67 #define HANDLE_PHENOME(x) case VMorpherPhenome::x: return AL_VOCAL_MORPHER_PHONEME_ ## x
  68     switch(phenome)
  69     {
  70     HANDLE_PHENOME(A);
  71     HANDLE_PHENOME(E);
  72     HANDLE_PHENOME(I);
  73     HANDLE_PHENOME(O);
  74     HANDLE_PHENOME(U);
  75     HANDLE_PHENOME(AA);
  76     HANDLE_PHENOME(AE);
  77     HANDLE_PHENOME(AH);
  78     HANDLE_PHENOME(AO);
  79     HANDLE_PHENOME(EH);
  80     HANDLE_PHENOME(ER);
  81     HANDLE_PHENOME(IH);
  82     HANDLE_PHENOME(IY);
  83     HANDLE_PHENOME(UH);
  84     HANDLE_PHENOME(UW);
  85     HANDLE_PHENOME(B);
  86     HANDLE_PHENOME(D);
  87     HANDLE_PHENOME(F);
  88     HANDLE_PHENOME(G);
  89     HANDLE_PHENOME(J);
  90     HANDLE_PHENOME(K);
  91     HANDLE_PHENOME(L);
  92     HANDLE_PHENOME(M);
  93     HANDLE_PHENOME(N);
  94     HANDLE_PHENOME(P);
  95     HANDLE_PHENOME(R);
  96     HANDLE_PHENOME(S);
  97     HANDLE_PHENOME(T);
  98     HANDLE_PHENOME(V);
  99     HANDLE_PHENOME(Z);
 100     }
 101     throw std::runtime_error{"Invalid phenome: "+std::to_string(static_cast<int>(phenome))};
 102 #undef HANDLE_PHENOME
 103 }
 104
 105 al::optional<VMorpherWaveform> WaveformFromEmum(ALenum value)
 106 {
 107     switch(value)
 108     {
 109     case AL_VOCAL_MORPHER_WAVEFORM_SINUSOID: return al::make_optional(VMorpherWaveform::Sinusoid);
 110     case AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE: return al::make_optional(VMorpherWaveform::Triangle);
 111     case AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH: return al::make_optional(VMorpherWaveform::Sawtooth);
 112     }
 113     return al::nullopt;
 114 }
 115 ALenum EnumFromWaveform(VMorpherWaveform type)
 116 {
 117     switch(type)
 118     {
 119     case VMorpherWaveform::Sinusoid: return AL_VOCAL_MORPHER_WAVEFORM_SINUSOID;
 120     case VMorpherWaveform::Triangle: return AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE;
 121     case VMorpherWaveform::Sawtooth: return AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH;
 122     }
 123     throw std::runtime_error{"Invalid vocal morpher waveform: " +
 124         std::to_string(static_cast<int>(type))};
 125 }
 126
 127 void Vmorpher_setParami(EffectProps *props, ALenum param, int val)
 128 {
 129     switch(param)
 130     {
 131     case AL_VOCAL_MORPHER_PHONEMEA:
 132         if(auto phenomeopt = PhenomeFromEnum(val))
 133             props->Vmorpher.PhonemeA = *phenomeopt;
 134         else
 135             throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-a out of range: 0x%04x", val};
 136         break;
 137
 138     case AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING:
 139         if(!(val >= AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING && val <= AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING))
 140             throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-a coarse tuning out of range"};
 141         props->Vmorpher.PhonemeACoarseTuning = val;
 142         break;
 143
 144     case AL_VOCAL_MORPHER_PHONEMEB:
 145         if(auto phenomeopt = PhenomeFromEnum(val))
 146             props->Vmorpher.PhonemeB = *phenomeopt;
 147         else
 148             throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-b out of range: 0x%04x", val};
 149         break;
 150
 151     case AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING:
 152         if(!(val >= AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING && val <= AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING))
 153             throw effect_exception{AL_INVALID_VALUE, "Vocal morpher phoneme-b coarse tuning out of range"};
 154         props->Vmorpher.PhonemeBCoarseTuning = val;
 155         break;
 156
 157     case AL_VOCAL_MORPHER_WAVEFORM:
 158         if(auto formopt = WaveformFromEmum(val))
 159             props->Vmorpher.Waveform = *formopt;
 160         else
 161             throw effect_exception{AL_INVALID_VALUE, "Vocal morpher waveform out of range: 0x%04x", val};
 162         break;
 163
 164     default:
 165         throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer property 0x%04x",
 166             param};
 167     }
 168 }
 169 void Vmorpher_setParamiv(EffectProps*, ALenum param, const int*)
 170 {
 171     throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer-vector property 0x%04x",
 172         param};
 173 }
 174 void Vmorpher_setParamf(EffectProps *props, ALenum param, float val)
 175 {
 176     switch(param)
 177     {
 178     case AL_VOCAL_MORPHER_RATE:
 179         if(!(val >= AL_VOCAL_MORPHER_MIN_RATE && val <= AL_VOCAL_MORPHER_MAX_RATE))
 180             throw effect_exception{AL_INVALID_VALUE, "Vocal morpher rate out of range"};
 181         props->Vmorpher.Rate = val;
 182         break;
 183
 184     default:
 185         throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher float property 0x%04x",
 186             param};
 187     }
 188 }
 189 void Vmorpher_setParamfv(EffectProps *props, ALenum param, const float *vals)
 190 { Vmorpher_setParamf(props, param, vals[0]); }
 191
 192 void Vmorpher_getParami(const EffectProps *props, ALenum param, int* val)
 193 {
 194     switch(param)
 195     {
 196     case AL_VOCAL_MORPHER_PHONEMEA:
 197         *val = EnumFromPhenome(props->Vmorpher.PhonemeA);
 198         break;
 199
 200     case AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING:
 201         *val = props->Vmorpher.PhonemeACoarseTuning;
 202         break;
 203
 204     case AL_VOCAL_MORPHER_PHONEMEB:
 205         *val = EnumFromPhenome(props->Vmorpher.PhonemeB);
 206         break;
 207
 208     case AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING:
 209         *val = props->Vmorpher.PhonemeBCoarseTuning;
 210         break;
 211
 212     case AL_VOCAL_MORPHER_WAVEFORM:
 213         *val = EnumFromWaveform(props->Vmorpher.Waveform);
 214         break;
 215
 216     default:
 217         throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer property 0x%04x",
 218             param};
 219     }
 220 }
 221 void Vmorpher_getParamiv(const EffectProps*, ALenum param, int*)
 222 {
 223     throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher integer-vector property 0x%04x",
 224         param};
 225 }
 226 void Vmorpher_getParamf(const EffectProps *props, ALenum param, float *val)
 227 {
 228     switch(param)
 229     {
 230     case AL_VOCAL_MORPHER_RATE:
 231         *val = props->Vmorpher.Rate;
 232         break;
 233
 234     default:
 235         throw effect_exception{AL_INVALID_ENUM, "Invalid vocal morpher float property 0x%04x",
 236             param};
 237     }
 238 }
 239 void Vmorpher_getParamfv(const EffectProps *props, ALenum param, float *vals)
 240 { Vmorpher_getParamf(props, param, vals); }
 241
 242 EffectProps genDefaultProps() noexcept
 243 {
 244     EffectProps props{};
 245     props.Vmorpher.Rate                 = AL_VOCAL_MORPHER_DEFAULT_RATE;
 246     props.Vmorpher.PhonemeA             = *PhenomeFromEnum(AL_VOCAL_MORPHER_DEFAULT_PHONEMEA);
 247     props.Vmorpher.PhonemeB             = *PhenomeFromEnum(AL_VOCAL_MORPHER_DEFAULT_PHONEMEB);
 248     props.Vmorpher.PhonemeACoarseTuning = AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING;
 249     props.Vmorpher.PhonemeBCoarseTuning = AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING;
 250     props.Vmorpher.Waveform             = *WaveformFromEmum(AL_VOCAL_MORPHER_DEFAULT_WAVEFORM);
 251     return props;
 252 }
 253
 254 } // namespace
 255
 256 DEFINE_ALEFFECT_VTABLE(Vmorpher);
 257
 258 const EffectProps VmorpherEffectProps{genDefaultProps()};
 259
 260 #ifdef ALSOFT_EAX
 261 namespace {
 262
 263 using EaxVocalMorpherEffectDirtyFlagsValue = std::uint_least8_t;
 264
 265 struct EaxVocalMorpherEffectDirtyFlags
 266 {
 267     using EaxIsBitFieldStruct = bool;
 268
 269     EaxVocalMorpherEffectDirtyFlagsValue ulPhonemeA : 1;
 270     EaxVocalMorpherEffectDirtyFlagsValue lPhonemeACoarseTuning : 1;
 271     EaxVocalMorpherEffectDirtyFlagsValue ulPhonemeB : 1;
 272     EaxVocalMorpherEffectDirtyFlagsValue lPhonemeBCoarseTuning : 1;
 273     EaxVocalMorpherEffectDirtyFlagsValue ulWaveform : 1;
 274     EaxVocalMorpherEffectDirtyFlagsValue flRate : 1;
 275 }; // EaxPitchShifterEffectDirtyFlags
 276
 277
 278 class EaxVocalMorpherEffect final :
 279     public EaxEffect
 280 {
 281 public:
 282     EaxVocalMorpherEffect();
 283
 284     void dispatch(const EaxEaxCall& eax_call) override;
 285
 286     // [[nodiscard]]
 287     bool apply_deferred() override;
 288
 289 private:
 290     EAXVOCALMORPHERPROPERTIES eax_{};
 291     EAXVOCALMORPHERPROPERTIES eax_d_{};
 292     EaxVocalMorpherEffectDirtyFlags eax_dirty_flags_{};
 293
 294     void set_eax_defaults();
 295
 296     void set_efx_phoneme_a();
 297     void set_efx_phoneme_a_coarse_tuning();
 298     void set_efx_phoneme_b();
 299     void set_efx_phoneme_b_coarse_tuning();
 300     void set_efx_waveform();
 301     void set_efx_rate();
 302     void set_efx_defaults();
 303
 304     void get(const EaxEaxCall& eax_call);
 305
 306     void validate_phoneme_a(unsigned long ulPhonemeA);
 307     void validate_phoneme_a_coarse_tuning(long lPhonemeACoarseTuning);
 308     void validate_phoneme_b(unsigned long ulPhonemeB);
 309     void validate_phoneme_b_coarse_tuning(long lPhonemeBCoarseTuning);
 310     void validate_waveform(unsigned long ulWaveform);
 311     void validate_rate(float flRate);
 312     void validate_all(const EAXVOCALMORPHERPROPERTIES& all);
 313
 314     void defer_phoneme_a(unsigned long ulPhonemeA);
 315     void defer_phoneme_a_coarse_tuning(long lPhonemeACoarseTuning);
 316     void defer_phoneme_b(unsigned long ulPhonemeB);
 317     void defer_phoneme_b_coarse_tuning(long lPhonemeBCoarseTuning);
 318     void defer_waveform(unsigned long ulWaveform);
 319     void defer_rate(float flRate);
 320     void defer_all(const EAXVOCALMORPHERPROPERTIES& all);
 321
 322     void defer_phoneme_a(const EaxEaxCall& eax_call);
 323     void defer_phoneme_a_coarse_tuning(const EaxEaxCall& eax_call);
 324     void defer_phoneme_b(const EaxEaxCall& eax_call);
 325     void defer_phoneme_b_coarse_tuning(const EaxEaxCall& eax_call);
 326     void defer_waveform(const EaxEaxCall& eax_call);
 327     void defer_rate(const EaxEaxCall& eax_call);
 328     void defer_all(const EaxEaxCall& eax_call);
 329
 330     void set(const EaxEaxCall& eax_call);
 331 }; // EaxVocalMorpherEffect
 332
 333
 334 class EaxVocalMorpherEffectException :
 335     public EaxException
 336 {
 337 public:
 338     explicit EaxVocalMorpherEffectException(
 339         const char* message)
 340         :
 341         EaxException{"EAX_VOCAL_MORPHER_EFFECT", message}
 342     {
 343     }
 344 }; // EaxVocalMorpherEffectException
 345
 346
 347 EaxVocalMorpherEffect::EaxVocalMorpherEffect()
 348     : EaxEffect{AL_EFFECT_VOCAL_MORPHER}
 349 {
 350     set_eax_defaults();
 351     set_efx_defaults();
 352 }
 353
 354 void EaxVocalMorpherEffect::dispatch(const EaxEaxCall& eax_call)
 355 {
 356     eax_call.is_get() ? get(eax_call) : set(eax_call);
 357 }
 358
 359 void EaxVocalMorpherEffect::set_eax_defaults()
 360 {
 361     eax_.ulPhonemeA = EAXVOCALMORPHER_DEFAULTPHONEMEA;
 362     eax_.lPhonemeACoarseTuning = EAXVOCALMORPHER_DEFAULTPHONEMEACOARSETUNING;
 363     eax_.ulPhonemeB = EAXVOCALMORPHER_DEFAULTPHONEMEB;
 364     eax_.lPhonemeBCoarseTuning = EAXVOCALMORPHER_DEFAULTPHONEMEBCOARSETUNING;
 365     eax_.ulWaveform = EAXVOCALMORPHER_DEFAULTWAVEFORM;
 366     eax_.flRate = EAXVOCALMORPHER_DEFAULTRATE;
 367
 368     eax_d_ = eax_;
 369 }
 370
 371 void EaxVocalMorpherEffect::set_efx_phoneme_a()
 372 {
 373     const auto phoneme_a = clamp(
 374         static_cast<ALint>(eax_.ulPhonemeA),
 375         AL_VOCAL_MORPHER_MIN_PHONEMEA,
 376         AL_VOCAL_MORPHER_MAX_PHONEMEA);
 377
 378     const auto efx_phoneme_a = PhenomeFromEnum(phoneme_a);
 379     assert(efx_phoneme_a.has_value());
 380     al_effect_props_.Vmorpher.PhonemeA = *efx_phoneme_a;
 381 }
 382
 383 void EaxVocalMorpherEffect::set_efx_phoneme_a_coarse_tuning()
 384 {
 385     const auto phoneme_a_coarse_tuning = clamp(
 386         static_cast<ALint>(eax_.lPhonemeACoarseTuning),
 387         AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING,
 388         AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING);
 389
 390     al_effect_props_.Vmorpher.PhonemeACoarseTuning = phoneme_a_coarse_tuning;
 391 }
 392
 393 void EaxVocalMorpherEffect::set_efx_phoneme_b()
 394 {
 395     const auto phoneme_b = clamp(
 396         static_cast<ALint>(eax_.ulPhonemeB),
 397         AL_VOCAL_MORPHER_MIN_PHONEMEB,
 398         AL_VOCAL_MORPHER_MAX_PHONEMEB);
 399
 400     const auto efx_phoneme_b = PhenomeFromEnum(phoneme_b);
 401     assert(efx_phoneme_b.has_value());
 402     al_effect_props_.Vmorpher.PhonemeB = *efx_phoneme_b;
 403 }
 404
 405 void EaxVocalMorpherEffect::set_efx_phoneme_b_coarse_tuning()
 406 {
 407     const auto phoneme_b_coarse_tuning = clamp(
 408         static_cast<ALint>(eax_.lPhonemeBCoarseTuning),
 409         AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING,
 410         AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING);
 411
 412     al_effect_props_.Vmorpher.PhonemeBCoarseTuning = phoneme_b_coarse_tuning;
 413 }
 414
 415 void EaxVocalMorpherEffect::set_efx_waveform()
 416 {
 417     const auto waveform = clamp(
 418         static_cast<ALint>(eax_.ulWaveform),
 419         AL_VOCAL_MORPHER_MIN_WAVEFORM,
 420         AL_VOCAL_MORPHER_MAX_WAVEFORM);
 421
 422     const auto wfx_waveform = WaveformFromEmum(waveform);
 423     assert(wfx_waveform.has_value());
 424     al_effect_props_.Vmorpher.Waveform = *wfx_waveform;
 425 }
 426
 427 void EaxVocalMorpherEffect::set_efx_rate()
 428 {
 429     const auto rate = clamp(
 430         eax_.flRate,
 431         AL_VOCAL_MORPHER_MIN_RATE,
 432         AL_VOCAL_MORPHER_MAX_RATE);
 433
 434     al_effect_props_.Vmorpher.Rate = rate;
 435 }
 436
 437 void EaxVocalMorpherEffect::set_efx_defaults()
 438 {
 439     set_efx_phoneme_a();
 440     set_efx_phoneme_a_coarse_tuning();
 441     set_efx_phoneme_b();
 442     set_efx_phoneme_b_coarse_tuning();
 443     set_efx_waveform();
 444     set_efx_rate();
 445 }
 446
 447 void EaxVocalMorpherEffect::get(const EaxEaxCall& eax_call)
 448 {
 449     switch(eax_call.get_property_id())
 450     {
 451         case EAXVOCALMORPHER_NONE:
 452             break;
 453
 454         case EAXVOCALMORPHER_ALLPARAMETERS:
 455             eax_call.set_value<EaxVocalMorpherEffectException>(eax_);
 456             break;
 457
 458         case EAXVOCALMORPHER_PHONEMEA:
 459             eax_call.set_value<EaxVocalMorpherEffectException>(eax_.ulPhonemeA);
 460             break;
 461
 462         case EAXVOCALMORPHER_PHONEMEACOARSETUNING:
 463             eax_call.set_value<EaxVocalMorpherEffectException>(eax_.lPhonemeACoarseTuning);
 464             break;
 465
 466         case EAXVOCALMORPHER_PHONEMEB:
 467             eax_call.set_value<EaxVocalMorpherEffectException>(eax_.ulPhonemeB);
 468             break;
 469
 470         case EAXVOCALMORPHER_PHONEMEBCOARSETUNING:
 471             eax_call.set_value<EaxVocalMorpherEffectException>(eax_.lPhonemeBCoarseTuning);
 472             break;
 473
 474         case EAXVOCALMORPHER_WAVEFORM:
 475             eax_call.set_value<EaxVocalMorpherEffectException>(eax_.ulWaveform);
 476             break;
 477
 478         case EAXVOCALMORPHER_RATE:
 479             eax_call.set_value<EaxVocalMorpherEffectException>(eax_.flRate);
 480             break;
 481
 482         default:
 483             throw EaxVocalMorpherEffectException{"Unsupported property id."};
 484     }
 485 }
 486
 487 void EaxVocalMorpherEffect::validate_phoneme_a(
 488     unsigned long ulPhonemeA)
 489 {
 490     eax_validate_range<EaxVocalMorpherEffectException>(
 491         "Phoneme A",
 492         ulPhonemeA,
 493         EAXVOCALMORPHER_MINPHONEMEA,
 494         EAXVOCALMORPHER_MAXPHONEMEA);
 495 }
 496
 497 void EaxVocalMorpherEffect::validate_phoneme_a_coarse_tuning(
 498     long lPhonemeACoarseTuning)
 499 {
 500     eax_validate_range<EaxVocalMorpherEffectException>(
 501         "Phoneme A Coarse Tuning",
 502         lPhonemeACoarseTuning,
 503         EAXVOCALMORPHER_MINPHONEMEACOARSETUNING,
 504         EAXVOCALMORPHER_MAXPHONEMEACOARSETUNING);
 505 }
 506
 507 void EaxVocalMorpherEffect::validate_phoneme_b(
 508     unsigned long ulPhonemeB)
 509 {
 510     eax_validate_range<EaxVocalMorpherEffectException>(
 511         "Phoneme B",
 512         ulPhonemeB,
 513         EAXVOCALMORPHER_MINPHONEMEB,
 514         EAXVOCALMORPHER_MAXPHONEMEB);
 515 }
 516
 517 void EaxVocalMorpherEffect::validate_phoneme_b_coarse_tuning(
 518     long lPhonemeBCoarseTuning)
 519 {
 520     eax_validate_range<EaxVocalMorpherEffectException>(
 521         "Phoneme B Coarse Tuning",
 522         lPhonemeBCoarseTuning,
 523         EAXVOCALMORPHER_MINPHONEMEBCOARSETUNING,
 524         EAXVOCALMORPHER_MAXPHONEMEBCOARSETUNING);
 525 }
 526
 527 void EaxVocalMorpherEffect::validate_waveform(
 528     unsigned long ulWaveform)
 529 {
 530     eax_validate_range<EaxVocalMorpherEffectException>(
 531         "Waveform",
 532         ulWaveform,
 533         EAXVOCALMORPHER_MINWAVEFORM,
 534         EAXVOCALMORPHER_MAXWAVEFORM);
 535 }
 536
 537 void EaxVocalMorpherEffect::validate_rate(
 538     float flRate)
 539 {
 540     eax_validate_range<EaxVocalMorpherEffectException>(
 541         "Rate",
 542         flRate,
 543         EAXVOCALMORPHER_MINRATE,
 544         EAXVOCALMORPHER_MAXRATE);
 545 }
 546
 547 void EaxVocalMorpherEffect::validate_all(
 548     const EAXVOCALMORPHERPROPERTIES& all)
 549 {
 550     validate_phoneme_a(all.ulPhonemeA);
 551     validate_phoneme_a_coarse_tuning(all.lPhonemeACoarseTuning);
 552     validate_phoneme_b(all.ulPhonemeB);
 553     validate_phoneme_b_coarse_tuning(all.lPhonemeBCoarseTuning);
 554     validate_waveform(all.ulWaveform);
 555     validate_rate(all.flRate);
 556 }
 557
 558 void EaxVocalMorpherEffect::defer_phoneme_a(
 559     unsigned long ulPhonemeA)
 560 {
 561     eax_d_.ulPhonemeA = ulPhonemeA;
 562     eax_dirty_flags_.ulPhonemeA = (eax_.ulPhonemeA != eax_d_.ulPhonemeA);
 563 }
 564
 565 void EaxVocalMorpherEffect::defer_phoneme_a_coarse_tuning(
 566     long lPhonemeACoarseTuning)
 567 {
 568     eax_d_.lPhonemeACoarseTuning = lPhonemeACoarseTuning;
 569     eax_dirty_flags_.lPhonemeACoarseTuning = (eax_.lPhonemeACoarseTuning != eax_d_.lPhonemeACoarseTuning);
 570 }
 571
 572 void EaxVocalMorpherEffect::defer_phoneme_b(
 573     unsigned long ulPhonemeB)
 574 {
 575     eax_d_.ulPhonemeB = ulPhonemeB;
 576     eax_dirty_flags_.ulPhonemeB = (eax_.ulPhonemeB != eax_d_.ulPhonemeB);
 577 }
 578
 579 void EaxVocalMorpherEffect::defer_phoneme_b_coarse_tuning(
 580     long lPhonemeBCoarseTuning)
 581 {
 582     eax_d_.lPhonemeBCoarseTuning = lPhonemeBCoarseTuning;
 583     eax_dirty_flags_.lPhonemeBCoarseTuning = (eax_.lPhonemeBCoarseTuning != eax_d_.lPhonemeBCoarseTuning);
 584 }
 585
 586 void EaxVocalMorpherEffect::defer_waveform(
 587     unsigned long ulWaveform)
 588 {
 589     eax_d_.ulWaveform = ulWaveform;
 590     eax_dirty_flags_.ulWaveform = (eax_.ulWaveform != eax_d_.ulWaveform);
 591 }
 592
 593 void EaxVocalMorpherEffect::defer_rate(
 594     float flRate)
 595 {
 596     eax_d_.flRate = flRate;
 597     eax_dirty_flags_.flRate = (eax_.flRate != eax_d_.flRate);
 598 }
 599
 600 void EaxVocalMorpherEffect::defer_all(
 601     const EAXVOCALMORPHERPROPERTIES& all)
 602 {
 603     defer_phoneme_a(all.ulPhonemeA);
 604     defer_phoneme_a_coarse_tuning(all.lPhonemeACoarseTuning);
 605     defer_phoneme_b(all.ulPhonemeB);
 606     defer_phoneme_b_coarse_tuning(all.lPhonemeBCoarseTuning);
 607     defer_waveform(all.ulWaveform);
 608     defer_rate(all.flRate);
 609 }
 610
 611 void EaxVocalMorpherEffect::defer_phoneme_a(
 612     const EaxEaxCall& eax_call)
 613 {
 614     const auto& phoneme_a = eax_call.get_value<EaxVocalMorpherEffectException,
 615         const decltype(EAXVOCALMORPHERPROPERTIES::ulPhonemeA)>();
 616
 617     validate_phoneme_a(phoneme_a);
 618     defer_phoneme_a(phoneme_a);
 619 }
 620
 621 void EaxVocalMorpherEffect::defer_phoneme_a_coarse_tuning(
 622     const EaxEaxCall& eax_call)
 623 {
 624     const auto& phoneme_a_coarse_tuning = eax_call.get_value<
 625         EaxVocalMorpherEffectException,
 626         const decltype(EAXVOCALMORPHERPROPERTIES::lPhonemeACoarseTuning)
 627     >();
 628
 629     validate_phoneme_a_coarse_tuning(phoneme_a_coarse_tuning);
 630     defer_phoneme_a_coarse_tuning(phoneme_a_coarse_tuning);
 631 }
 632
 633 void EaxVocalMorpherEffect::defer_phoneme_b(
 634     const EaxEaxCall& eax_call)
 635 {
 636     const auto& phoneme_b = eax_call.get_value<
 637         EaxVocalMorpherEffectException,
 638         const decltype(EAXVOCALMORPHERPROPERTIES::ulPhonemeB)
 639     >();
 640
 641     validate_phoneme_b(phoneme_b);
 642     defer_phoneme_b(phoneme_b);
 643 }
 644
 645 void EaxVocalMorpherEffect::defer_phoneme_b_coarse_tuning(
 646     const EaxEaxCall& eax_call)
 647 {
 648     const auto& phoneme_b_coarse_tuning = eax_call.get_value<
 649         EaxVocalMorpherEffectException,
 650         const decltype(EAXVOCALMORPHERPROPERTIES::lPhonemeBCoarseTuning)
 651     >();
 652
 653     validate_phoneme_b_coarse_tuning(phoneme_b_coarse_tuning);
 654     defer_phoneme_b_coarse_tuning(phoneme_b_coarse_tuning);
 655 }
 656
 657 void EaxVocalMorpherEffect::defer_waveform(
 658     const EaxEaxCall& eax_call)
 659 {
 660     const auto& waveform = eax_call.get_value<
 661         EaxVocalMorpherEffectException,
 662         const decltype(EAXVOCALMORPHERPROPERTIES::ulWaveform)
 663     >();
 664
 665     validate_waveform(waveform);
 666     defer_waveform(waveform);
 667 }
 668
 669 void EaxVocalMorpherEffect::defer_rate(
 670     const EaxEaxCall& eax_call)
 671 {
 672     const auto& rate = eax_call.get_value<
 673         EaxVocalMorpherEffectException,
 674         const decltype(EAXVOCALMORPHERPROPERTIES::flRate)
 675     >();
 676
 677     validate_rate(rate);
 678     defer_rate(rate);
 679 }
 680
 681 void EaxVocalMorpherEffect::defer_all(
 682     const EaxEaxCall& eax_call)
 683 {
 684     const auto& all = eax_call.get_value<
 685         EaxVocalMorpherEffectException,
 686         const EAXVOCALMORPHERPROPERTIES
 687     >();
 688
 689     validate_all(all);
 690     defer_all(all);
 691 }
 692
 693 // [[nodiscard]]
 694 bool EaxVocalMorpherEffect::apply_deferred()
 695 {
 696     if (eax_dirty_flags_ == EaxVocalMorpherEffectDirtyFlags{})
 697     {
 698         return false;
 699     }
 700
 701     eax_ = eax_d_;
 702
 703     if (eax_dirty_flags_.ulPhonemeA)
 704     {
 705         set_efx_phoneme_a();
 706     }
 707
 708     if (eax_dirty_flags_.lPhonemeACoarseTuning)
 709     {
 710         set_efx_phoneme_a_coarse_tuning();
 711     }
 712
 713     if (eax_dirty_flags_.ulPhonemeB)
 714     {
 715         set_efx_phoneme_b();
 716     }
 717
 718     if (eax_dirty_flags_.lPhonemeBCoarseTuning)
 719     {
 720         set_efx_phoneme_b_coarse_tuning();
 721     }
 722
 723     if (eax_dirty_flags_.ulWaveform)
 724     {
 725         set_efx_waveform();
 726     }
 727
 728     if (eax_dirty_flags_.flRate)
 729     {
 730         set_efx_rate();
 731     }
 732
 733     eax_dirty_flags_ = EaxVocalMorpherEffectDirtyFlags{};
 734
 735     return true;
 736 }
 737
 738 void EaxVocalMorpherEffect::set(const EaxEaxCall& eax_call)
 739 {
 740     switch(eax_call.get_property_id())
 741     {
 742         case EAXVOCALMORPHER_NONE:
 743             break;
 744
 745         case EAXVOCALMORPHER_ALLPARAMETERS:
 746             defer_all(eax_call);
 747             break;
 748
 749         case EAXVOCALMORPHER_PHONEMEA:
 750             defer_phoneme_a(eax_call);
 751             break;
 752
 753         case EAXVOCALMORPHER_PHONEMEACOARSETUNING:
 754             defer_phoneme_a_coarse_tuning(eax_call);
 755             break;
 756
 757         case EAXVOCALMORPHER_PHONEMEB:
 758             defer_phoneme_b(eax_call);
 759             break;
 760
 761         case EAXVOCALMORPHER_PHONEMEBCOARSETUNING:
 762             defer_phoneme_b_coarse_tuning(eax_call);
 763             break;
 764
 765         case EAXVOCALMORPHER_WAVEFORM:
 766             defer_waveform(eax_call);
 767             break;
 768
 769         case EAXVOCALMORPHER_RATE:
 770             defer_rate(eax_call);
 771             break;
 772
 773         default:
 774             throw EaxVocalMorpherEffectException{"Unsupported property id."};
 775     }
 776 }
 777
 778 } // namespace
 779
 780
 781 EaxEffectUPtr eax_create_eax_vocal_morpher_effect()
 782 {
 783     return std::make_unique<EaxVocalMorpherEffect>();
 784 }
 785
 786 #endif // ALSOFT_EAX