al/effects/distortion.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 void Distortion_setParami(EffectProps*, ALenum param, int)
  21 { throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param}; }
  22 void Distortion_setParamiv(EffectProps*, ALenum param, const int*)
  23 {
  24     throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x",
  25         param};
  26 }
  27 void Distortion_setParamf(EffectProps *props, ALenum param, float val)
  28 {
  29     switch(param)
  30     {
  31     case AL_DISTORTION_EDGE:
  32         if(!(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE))
  33             throw effect_exception{AL_INVALID_VALUE, "Distortion edge out of range"};
  34         props->Distortion.Edge = val;
  35         break;
  36
  37     case AL_DISTORTION_GAIN:
  38         if(!(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN))
  39             throw effect_exception{AL_INVALID_VALUE, "Distortion gain out of range"};
  40         props->Distortion.Gain = val;
  41         break;
  42
  43     case AL_DISTORTION_LOWPASS_CUTOFF:
  44         if(!(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF))
  45             throw effect_exception{AL_INVALID_VALUE, "Distortion low-pass cutoff out of range"};
  46         props->Distortion.LowpassCutoff = val;
  47         break;
  48
  49     case AL_DISTORTION_EQCENTER:
  50         if(!(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER))
  51             throw effect_exception{AL_INVALID_VALUE, "Distortion EQ center out of range"};
  52         props->Distortion.EQCenter = val;
  53         break;
  54
  55     case AL_DISTORTION_EQBANDWIDTH:
  56         if(!(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH))
  57             throw effect_exception{AL_INVALID_VALUE, "Distortion EQ bandwidth out of range"};
  58         props->Distortion.EQBandwidth = val;
  59         break;
  60
  61     default:
  62         throw effect_exception{AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param};
  63     }
  64 }
  65 void Distortion_setParamfv(EffectProps *props, ALenum param, const float *vals)
  66 { Distortion_setParamf(props, param, vals[0]); }
  67
  68 void Distortion_getParami(const EffectProps*, ALenum param, int*)
  69 { throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param}; }
  70 void Distortion_getParamiv(const EffectProps*, ALenum param, int*)
  71 {
  72     throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x",
  73         param};
  74 }
  75 void Distortion_getParamf(const EffectProps *props, ALenum param, float *val)
  76 {
  77     switch(param)
  78     {
  79     case AL_DISTORTION_EDGE:
  80         *val = props->Distortion.Edge;
  81         break;
  82
  83     case AL_DISTORTION_GAIN:
  84         *val = props->Distortion.Gain;
  85         break;
  86
  87     case AL_DISTORTION_LOWPASS_CUTOFF:
  88         *val = props->Distortion.LowpassCutoff;
  89         break;
  90
  91     case AL_DISTORTION_EQCENTER:
  92         *val = props->Distortion.EQCenter;
  93         break;
  94
  95     case AL_DISTORTION_EQBANDWIDTH:
  96         *val = props->Distortion.EQBandwidth;
  97         break;
  98
  99     default:
 100         throw effect_exception{AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param};
 101     }
 102 }
 103 void Distortion_getParamfv(const EffectProps *props, ALenum param, float *vals)
 104 { Distortion_getParamf(props, param, vals); }
 105
 106 EffectProps genDefaultProps() noexcept
 107 {
 108     EffectProps props{};
 109     props.Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE;
 110     props.Distortion.Gain = AL_DISTORTION_DEFAULT_GAIN;
 111     props.Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF;
 112     props.Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER;
 113     props.Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH;
 114     return props;
 115 }
 116
 117 } // namespace
 118
 119 DEFINE_ALEFFECT_VTABLE(Distortion);
 120
 121 const EffectProps DistortionEffectProps{genDefaultProps()};
 122
 123 #ifdef ALSOFT_EAX
 124 namespace {
 125
 126 using EaxDistortionEffectDirtyFlagsValue = std::uint_least8_t;
 127
 128 struct EaxDistortionEffectDirtyFlags
 129 {
 130     using EaxIsBitFieldStruct = bool;
 131
 132     EaxDistortionEffectDirtyFlagsValue flEdge : 1;
 133     EaxDistortionEffectDirtyFlagsValue lGain : 1;
 134     EaxDistortionEffectDirtyFlagsValue flLowPassCutOff : 1;
 135     EaxDistortionEffectDirtyFlagsValue flEQCenter : 1;
 136     EaxDistortionEffectDirtyFlagsValue flEQBandwidth : 1;
 137 }; // EaxDistortionEffectDirtyFlags
 138
 139
 140 class EaxDistortionEffect final :
 141     public EaxEffect
 142 {
 143 public:
 144     EaxDistortionEffect();
 145
 146     void dispatch(const EaxEaxCall& eax_call) override;
 147
 148     // [[nodiscard]]
 149     bool apply_deferred() override;
 150
 151 private:
 152     EAXDISTORTIONPROPERTIES eax_{};
 153     EAXDISTORTIONPROPERTIES eax_d_{};
 154     EaxDistortionEffectDirtyFlags eax_dirty_flags_{};
 155
 156     void set_eax_defaults();
 157
 158     void set_efx_edge();
 159     void set_efx_gain();
 160     void set_efx_lowpass_cutoff();
 161     void set_efx_eq_center();
 162     void set_efx_eq_bandwidth();
 163     void set_efx_defaults();
 164
 165     void get(const EaxEaxCall& eax_call);
 166
 167     void validate_edge(float flEdge);
 168     void validate_gain(long lGain);
 169     void validate_lowpass_cutoff(float flLowPassCutOff);
 170     void validate_eq_center(float flEQCenter);
 171     void validate_eq_bandwidth(float flEQBandwidth);
 172     void validate_all(const EAXDISTORTIONPROPERTIES& eax_all);
 173
 174     void defer_edge(float flEdge);
 175     void defer_gain(long lGain);
 176     void defer_low_pass_cutoff(float flLowPassCutOff);
 177     void defer_eq_center(float flEQCenter);
 178     void defer_eq_bandwidth(float flEQBandwidth);
 179     void defer_all(const EAXDISTORTIONPROPERTIES& eax_all);
 180
 181     void defer_edge(const EaxEaxCall& eax_call);
 182     void defer_gain(const EaxEaxCall& eax_call);
 183     void defer_low_pass_cutoff(const EaxEaxCall& eax_call);
 184     void defer_eq_center(const EaxEaxCall& eax_call);
 185     void defer_eq_bandwidth(const EaxEaxCall& eax_call);
 186     void defer_all(const EaxEaxCall& eax_call);
 187
 188     void set(const EaxEaxCall& eax_call);
 189 }; // EaxDistortionEffect
 190
 191
 192 class EaxDistortionEffectException :
 193     public EaxException
 194 {
 195 public:
 196     explicit EaxDistortionEffectException(
 197         const char* message)
 198         :
 199         EaxException{"EAX_DISTORTION_EFFECT", message}
 200     {
 201     }
 202 }; // EaxDistortionEffectException
 203
 204
 205 EaxDistortionEffect::EaxDistortionEffect()
 206     : EaxEffect{AL_EFFECT_DISTORTION}
 207 {
 208     set_eax_defaults();
 209     set_efx_defaults();
 210 }
 211
 212 void EaxDistortionEffect::dispatch(const EaxEaxCall& eax_call)
 213 {
 214     eax_call.is_get() ? get(eax_call) : set(eax_call);
 215 }
 216
 217 void EaxDistortionEffect::set_eax_defaults()
 218 {
 219     eax_.flEdge = EAXDISTORTION_DEFAULTEDGE;
 220     eax_.lGain = EAXDISTORTION_DEFAULTGAIN;
 221     eax_.flLowPassCutOff = EAXDISTORTION_DEFAULTLOWPASSCUTOFF;
 222     eax_.flEQCenter = EAXDISTORTION_DEFAULTEQCENTER;
 223     eax_.flEQBandwidth = EAXDISTORTION_DEFAULTEQBANDWIDTH;
 224
 225     eax_d_ = eax_;
 226 }
 227
 228 void EaxDistortionEffect::set_efx_edge()
 229 {
 230     const auto edge = clamp(
 231         eax_.flEdge,
 232         AL_DISTORTION_MIN_EDGE,
 233         AL_DISTORTION_MAX_EDGE);
 234
 235     al_effect_props_.Distortion.Edge = edge;
 236 }
 237
 238 void EaxDistortionEffect::set_efx_gain()
 239 {
 240     const auto gain = clamp(
 241         level_mb_to_gain(static_cast<float>(eax_.lGain)),
 242         AL_DISTORTION_MIN_GAIN,
 243         AL_DISTORTION_MAX_GAIN);
 244
 245     al_effect_props_.Distortion.Gain = gain;
 246 }
 247
 248 void EaxDistortionEffect::set_efx_lowpass_cutoff()
 249 {
 250     const auto lowpass_cutoff = clamp(
 251         eax_.flLowPassCutOff,
 252         AL_DISTORTION_MIN_LOWPASS_CUTOFF,
 253         AL_DISTORTION_MAX_LOWPASS_CUTOFF);
 254
 255     al_effect_props_.Distortion.LowpassCutoff = lowpass_cutoff;
 256 }
 257
 258 void EaxDistortionEffect::set_efx_eq_center()
 259 {
 260     const auto eq_center = clamp(
 261         eax_.flEQCenter,
 262         AL_DISTORTION_MIN_EQCENTER,
 263         AL_DISTORTION_MAX_EQCENTER);
 264
 265     al_effect_props_.Distortion.EQCenter = eq_center;
 266 }
 267
 268 void EaxDistortionEffect::set_efx_eq_bandwidth()
 269 {
 270     const auto eq_bandwidth = clamp(
 271         eax_.flEdge,
 272         AL_DISTORTION_MIN_EQBANDWIDTH,
 273         AL_DISTORTION_MAX_EQBANDWIDTH);
 274
 275     al_effect_props_.Distortion.EQBandwidth = eq_bandwidth;
 276 }
 277
 278 void EaxDistortionEffect::set_efx_defaults()
 279 {
 280     set_efx_edge();
 281     set_efx_gain();
 282     set_efx_lowpass_cutoff();
 283     set_efx_eq_center();
 284     set_efx_eq_bandwidth();
 285 }
 286
 287 void EaxDistortionEffect::get(const EaxEaxCall& eax_call)
 288 {
 289     switch(eax_call.get_property_id())
 290     {
 291         case EAXDISTORTION_NONE:
 292             break;
 293
 294         case EAXDISTORTION_ALLPARAMETERS:
 295             eax_call.set_value<EaxDistortionEffectException>(eax_);
 296             break;
 297
 298         case EAXDISTORTION_EDGE:
 299             eax_call.set_value<EaxDistortionEffectException>(eax_.flEdge);
 300             break;
 301
 302         case EAXDISTORTION_GAIN:
 303             eax_call.set_value<EaxDistortionEffectException>(eax_.lGain);
 304             break;
 305
 306         case EAXDISTORTION_LOWPASSCUTOFF:
 307             eax_call.set_value<EaxDistortionEffectException>(eax_.flLowPassCutOff);
 308             break;
 309
 310         case EAXDISTORTION_EQCENTER:
 311             eax_call.set_value<EaxDistortionEffectException>(eax_.flEQCenter);
 312             break;
 313
 314         case EAXDISTORTION_EQBANDWIDTH:
 315             eax_call.set_value<EaxDistortionEffectException>(eax_.flEQBandwidth);
 316             break;
 317
 318         default:
 319             throw EaxDistortionEffectException{"Unsupported property id."};
 320     }
 321 }
 322
 323 void EaxDistortionEffect::validate_edge(
 324     float flEdge)
 325 {
 326     eax_validate_range<EaxDistortionEffectException>(
 327         "Edge",
 328         flEdge,
 329         EAXDISTORTION_MINEDGE,
 330         EAXDISTORTION_MAXEDGE);
 331 }
 332
 333 void EaxDistortionEffect::validate_gain(
 334     long lGain)
 335 {
 336     eax_validate_range<EaxDistortionEffectException>(
 337         "Gain",
 338         lGain,
 339         EAXDISTORTION_MINGAIN,
 340         EAXDISTORTION_MAXGAIN);
 341 }
 342
 343 void EaxDistortionEffect::validate_lowpass_cutoff(
 344     float flLowPassCutOff)
 345 {
 346     eax_validate_range<EaxDistortionEffectException>(
 347         "Low-pass Cut-off",
 348         flLowPassCutOff,
 349         EAXDISTORTION_MINLOWPASSCUTOFF,
 350         EAXDISTORTION_MAXLOWPASSCUTOFF);
 351 }
 352
 353 void EaxDistortionEffect::validate_eq_center(
 354     float flEQCenter)
 355 {
 356     eax_validate_range<EaxDistortionEffectException>(
 357         "EQ Center",
 358         flEQCenter,
 359         EAXDISTORTION_MINEQCENTER,
 360         EAXDISTORTION_MAXEQCENTER);
 361 }
 362
 363 void EaxDistortionEffect::validate_eq_bandwidth(
 364     float flEQBandwidth)
 365 {
 366     eax_validate_range<EaxDistortionEffectException>(
 367         "EQ Bandwidth",
 368         flEQBandwidth,
 369         EAXDISTORTION_MINEQBANDWIDTH,
 370         EAXDISTORTION_MAXEQBANDWIDTH);
 371 }
 372
 373 void EaxDistortionEffect::validate_all(
 374     const EAXDISTORTIONPROPERTIES& eax_all)
 375 {
 376     validate_edge(eax_all.flEdge);
 377     validate_gain(eax_all.lGain);
 378     validate_lowpass_cutoff(eax_all.flLowPassCutOff);
 379     validate_eq_center(eax_all.flEQCenter);
 380     validate_eq_bandwidth(eax_all.flEQBandwidth);
 381 }
 382
 383 void EaxDistortionEffect::defer_edge(
 384     float flEdge)
 385 {
 386     eax_d_.flEdge = flEdge;
 387     eax_dirty_flags_.flEdge = (eax_.flEdge != eax_d_.flEdge);
 388 }
 389
 390 void EaxDistortionEffect::defer_gain(
 391     long lGain)
 392 {
 393     eax_d_.lGain = lGain;
 394     eax_dirty_flags_.lGain = (eax_.lGain != eax_d_.lGain);
 395 }
 396
 397 void EaxDistortionEffect::defer_low_pass_cutoff(
 398     float flLowPassCutOff)
 399 {
 400     eax_d_.flLowPassCutOff = flLowPassCutOff;
 401     eax_dirty_flags_.flLowPassCutOff = (eax_.flLowPassCutOff != eax_d_.flLowPassCutOff);
 402 }
 403
 404 void EaxDistortionEffect::defer_eq_center(
 405     float flEQCenter)
 406 {
 407     eax_d_.flEQCenter = flEQCenter;
 408     eax_dirty_flags_.flEQCenter = (eax_.flEQCenter != eax_d_.flEQCenter);
 409 }
 410
 411 void EaxDistortionEffect::defer_eq_bandwidth(
 412     float flEQBandwidth)
 413 {
 414     eax_d_.flEQBandwidth = flEQBandwidth;
 415     eax_dirty_flags_.flEQBandwidth = (eax_.flEQBandwidth != eax_d_.flEQBandwidth);
 416 }
 417
 418 void EaxDistortionEffect::defer_all(
 419     const EAXDISTORTIONPROPERTIES& eax_all)
 420 {
 421     defer_edge(eax_all.flEdge);
 422     defer_gain(eax_all.lGain);
 423     defer_low_pass_cutoff(eax_all.flLowPassCutOff);
 424     defer_eq_center(eax_all.flEQCenter);
 425     defer_eq_bandwidth(eax_all.flEQBandwidth);
 426 }
 427
 428 void EaxDistortionEffect::defer_edge(
 429     const EaxEaxCall& eax_call)
 430 {
 431     const auto& edge =
 432         eax_call.get_value<EaxDistortionEffectException, const decltype(EAXDISTORTIONPROPERTIES::flEdge)>();
 433
 434     validate_edge(edge);
 435     defer_edge(edge);
 436 }
 437
 438 void EaxDistortionEffect::defer_gain(
 439     const EaxEaxCall& eax_call)
 440 {
 441     const auto& gain =
 442         eax_call.get_value<EaxDistortionEffectException, const decltype(EAXDISTORTIONPROPERTIES::lGain)>();
 443
 444     validate_gain(gain);
 445     defer_gain(gain);
 446 }
 447
 448 void EaxDistortionEffect::defer_low_pass_cutoff(
 449     const EaxEaxCall& eax_call)
 450 {
 451     const auto& lowpass_cutoff =
 452         eax_call.get_value<EaxDistortionEffectException, const decltype(EAXDISTORTIONPROPERTIES::flLowPassCutOff)>();
 453
 454     validate_lowpass_cutoff(lowpass_cutoff);
 455     defer_low_pass_cutoff(lowpass_cutoff);
 456 }
 457
 458 void EaxDistortionEffect::defer_eq_center(
 459     const EaxEaxCall& eax_call)
 460 {
 461     const auto& eq_center =
 462         eax_call.get_value<EaxDistortionEffectException, const decltype(EAXDISTORTIONPROPERTIES::flEQCenter)>();
 463
 464     validate_eq_center(eq_center);
 465     defer_eq_center(eq_center);
 466 }
 467
 468 void EaxDistortionEffect::defer_eq_bandwidth(
 469     const EaxEaxCall& eax_call)
 470 {
 471     const auto& eq_bandwidth =
 472         eax_call.get_value<EaxDistortionEffectException, const decltype(EAXDISTORTIONPROPERTIES::flEQBandwidth)>();
 473
 474     validate_eq_bandwidth(eq_bandwidth);
 475     defer_eq_bandwidth(eq_bandwidth);
 476 }
 477
 478 void EaxDistortionEffect::defer_all(
 479     const EaxEaxCall& eax_call)
 480 {
 481     const auto& all =
 482         eax_call.get_value<EaxDistortionEffectException, const EAXDISTORTIONPROPERTIES>();
 483
 484     validate_all(all);
 485     defer_all(all);
 486 }
 487
 488 // [[nodiscard]]
 489 bool EaxDistortionEffect::apply_deferred()
 490 {
 491     if (eax_dirty_flags_ == EaxDistortionEffectDirtyFlags{})
 492     {
 493         return false;
 494     }
 495
 496     eax_ = eax_d_;
 497
 498     if (eax_dirty_flags_.flEdge)
 499     {
 500         set_efx_edge();
 501     }
 502
 503     if (eax_dirty_flags_.lGain)
 504     {
 505         set_efx_gain();
 506     }
 507
 508     if (eax_dirty_flags_.flLowPassCutOff)
 509     {
 510         set_efx_lowpass_cutoff();
 511     }
 512
 513     if (eax_dirty_flags_.flEQCenter)
 514     {
 515         set_efx_eq_center();
 516     }
 517
 518     if (eax_dirty_flags_.flEQBandwidth)
 519     {
 520         set_efx_eq_bandwidth();
 521     }
 522
 523     eax_dirty_flags_ = EaxDistortionEffectDirtyFlags{};
 524
 525     return true;
 526 }
 527
 528 void EaxDistortionEffect::set(const EaxEaxCall& eax_call)
 529 {
 530     switch(eax_call.get_property_id())
 531     {
 532         case EAXDISTORTION_NONE:
 533             break;
 534
 535         case EAXDISTORTION_ALLPARAMETERS:
 536             defer_all(eax_call);
 537             break;
 538
 539         case EAXDISTORTION_EDGE:
 540             defer_edge(eax_call);
 541             break;
 542
 543         case EAXDISTORTION_GAIN:
 544             defer_gain(eax_call);
 545             break;
 546
 547         case EAXDISTORTION_LOWPASSCUTOFF:
 548             defer_low_pass_cutoff(eax_call);
 549             break;
 550
 551         case EAXDISTORTION_EQCENTER:
 552             defer_eq_center(eax_call);
 553             break;
 554
 555         case EAXDISTORTION_EQBANDWIDTH:
 556             defer_eq_bandwidth(eax_call);
 557             break;
 558
 559         default:
 560             throw EaxDistortionEffectException{"Unsupported property id."};
 561     }
 562 }
 563
 564 } // namespace
 565
 566 EaxEffectUPtr eax_create_eax_distortion_effect()
 567 {
 568     return std::make_unique<EaxDistortionEffect>();
 569 }
 570
 571 #endif // ALSOFT_EAX