al/effects/pshifter.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 Pshifter_setParamf(EffectProps*, ALenum param, float)
  21 { throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param}; }
  22 void Pshifter_setParamfv(EffectProps*, ALenum param, const float*)
  23 {
  24     throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float-vector property 0x%04x",
  25         param};
  26 }
  27
  28 void Pshifter_setParami(EffectProps *props, ALenum param, int val)
  29 {
  30     switch(param)
  31     {
  32     case AL_PITCH_SHIFTER_COARSE_TUNE:
  33         if(!(val >= AL_PITCH_SHIFTER_MIN_COARSE_TUNE && val <= AL_PITCH_SHIFTER_MAX_COARSE_TUNE))
  34             throw effect_exception{AL_INVALID_VALUE, "Pitch shifter coarse tune out of range"};
  35         props->Pshifter.CoarseTune = val;
  36         break;
  37
  38     case AL_PITCH_SHIFTER_FINE_TUNE:
  39         if(!(val >= AL_PITCH_SHIFTER_MIN_FINE_TUNE && val <= AL_PITCH_SHIFTER_MAX_FINE_TUNE))
  40             throw effect_exception{AL_INVALID_VALUE, "Pitch shifter fine tune out of range"};
  41         props->Pshifter.FineTune = val;
  42         break;
  43
  44     default:
  45         throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x",
  46             param};
  47     }
  48 }
  49 void Pshifter_setParamiv(EffectProps *props, ALenum param, const int *vals)
  50 { Pshifter_setParami(props, param, vals[0]); }
  51
  52 void Pshifter_getParami(const EffectProps *props, ALenum param, int *val)
  53 {
  54     switch(param)
  55     {
  56     case AL_PITCH_SHIFTER_COARSE_TUNE:
  57         *val = props->Pshifter.CoarseTune;
  58         break;
  59     case AL_PITCH_SHIFTER_FINE_TUNE:
  60         *val = props->Pshifter.FineTune;
  61         break;
  62
  63     default:
  64         throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter integer property 0x%04x",
  65             param};
  66     }
  67 }
  68 void Pshifter_getParamiv(const EffectProps *props, ALenum param, int *vals)
  69 { Pshifter_getParami(props, param, vals); }
  70
  71 void Pshifter_getParamf(const EffectProps*, ALenum param, float*)
  72 { throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float property 0x%04x", param}; }
  73 void Pshifter_getParamfv(const EffectProps*, ALenum param, float*)
  74 {
  75     throw effect_exception{AL_INVALID_ENUM, "Invalid pitch shifter float vector-property 0x%04x",
  76         param};
  77 }
  78
  79 EffectProps genDefaultProps() noexcept
  80 {
  81     EffectProps props{};
  82     props.Pshifter.CoarseTune = AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE;
  83     props.Pshifter.FineTune   = AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE;
  84     return props;
  85 }
  86
  87 } // namespace
  88
  89 DEFINE_ALEFFECT_VTABLE(Pshifter);
  90
  91 const EffectProps PshifterEffectProps{genDefaultProps()};
  92
  93 #ifdef ALSOFT_EAX
  94 namespace {
  95
  96 using EaxPitchShifterEffectDirtyFlagsValue = std::uint_least8_t;
  97
  98 struct EaxPitchShifterEffectDirtyFlags
  99 {
 100     using EaxIsBitFieldStruct = bool;
 101
 102     EaxPitchShifterEffectDirtyFlagsValue lCoarseTune : 1;
 103     EaxPitchShifterEffectDirtyFlagsValue lFineTune : 1;
 104 }; // EaxPitchShifterEffectDirtyFlags
 105
 106
 107 class EaxPitchShifterEffect final :
 108     public EaxEffect
 109 {
 110 public:
 111     EaxPitchShifterEffect();
 112
 113     void dispatch(const EaxEaxCall& eax_call) override;
 114
 115     // [[nodiscard]]
 116     bool apply_deferred() override;
 117
 118 private:
 119     EAXPITCHSHIFTERPROPERTIES eax_{};
 120     EAXPITCHSHIFTERPROPERTIES eax_d_{};
 121     EaxPitchShifterEffectDirtyFlags eax_dirty_flags_{};
 122
 123     void set_eax_defaults();
 124
 125     void set_efx_coarse_tune();
 126     void set_efx_fine_tune();
 127     void set_efx_defaults();
 128
 129     void get(const EaxEaxCall& eax_call);
 130
 131     void validate_coarse_tune(long lCoarseTune);
 132     void validate_fine_tune(long lFineTune);
 133     void validate_all(const EAXPITCHSHIFTERPROPERTIES& all);
 134
 135     void defer_coarse_tune(long lCoarseTune);
 136     void defer_fine_tune(long lFineTune);
 137     void defer_all(const EAXPITCHSHIFTERPROPERTIES& all);
 138
 139     void defer_coarse_tune(const EaxEaxCall& eax_call);
 140     void defer_fine_tune(const EaxEaxCall& eax_call);
 141     void defer_all(const EaxEaxCall& eax_call);
 142
 143     void set(const EaxEaxCall& eax_call);
 144 }; // EaxPitchShifterEffect
 145
 146
 147 class EaxPitchShifterEffectException :
 148     public EaxException
 149 {
 150 public:
 151     explicit EaxPitchShifterEffectException(
 152         const char* message)
 153         :
 154         EaxException{"EAX_PITCH_SHIFTER_EFFECT", message}
 155     {
 156     }
 157 }; // EaxPitchShifterEffectException
 158
 159
 160 EaxPitchShifterEffect::EaxPitchShifterEffect()
 161     : EaxEffect{AL_EFFECT_PITCH_SHIFTER}
 162 {
 163     set_eax_defaults();
 164     set_efx_defaults();
 165 }
 166
 167 void EaxPitchShifterEffect::dispatch(const EaxEaxCall& eax_call)
 168 {
 169     eax_call.is_get() ? get(eax_call) : set(eax_call);
 170 }
 171
 172 void EaxPitchShifterEffect::set_eax_defaults()
 173 {
 174     eax_.lCoarseTune = EAXPITCHSHIFTER_DEFAULTCOARSETUNE;
 175     eax_.lFineTune = EAXPITCHSHIFTER_DEFAULTFINETUNE;
 176
 177     eax_d_ = eax_;
 178 }
 179
 180 void EaxPitchShifterEffect::set_efx_coarse_tune()
 181 {
 182     const auto coarse_tune = clamp(
 183         static_cast<ALint>(eax_.lCoarseTune),
 184         AL_PITCH_SHIFTER_MIN_COARSE_TUNE,
 185         AL_PITCH_SHIFTER_MAX_COARSE_TUNE);
 186
 187     al_effect_props_.Pshifter.CoarseTune = coarse_tune;
 188 }
 189
 190 void EaxPitchShifterEffect::set_efx_fine_tune()
 191 {
 192     const auto fine_tune = clamp(
 193         static_cast<ALint>(eax_.lFineTune),
 194         AL_PITCH_SHIFTER_MIN_FINE_TUNE,
 195         AL_PITCH_SHIFTER_MAX_FINE_TUNE);
 196
 197     al_effect_props_.Pshifter.FineTune = fine_tune;
 198 }
 199
 200 void EaxPitchShifterEffect::set_efx_defaults()
 201 {
 202     set_efx_coarse_tune();
 203     set_efx_fine_tune();
 204 }
 205
 206 void EaxPitchShifterEffect::get(const EaxEaxCall& eax_call)
 207 {
 208     switch(eax_call.get_property_id())
 209     {
 210         case EAXPITCHSHIFTER_NONE:
 211             break;
 212
 213         case EAXPITCHSHIFTER_ALLPARAMETERS:
 214             eax_call.set_value<EaxPitchShifterEffectException>(eax_);
 215             break;
 216
 217         case EAXPITCHSHIFTER_COARSETUNE:
 218             eax_call.set_value<EaxPitchShifterEffectException>(eax_.lCoarseTune);
 219             break;
 220
 221         case EAXPITCHSHIFTER_FINETUNE:
 222             eax_call.set_value<EaxPitchShifterEffectException>(eax_.lFineTune);
 223             break;
 224
 225         default:
 226             throw EaxPitchShifterEffectException{"Unsupported property id."};
 227     }
 228 }
 229
 230 void EaxPitchShifterEffect::validate_coarse_tune(
 231     long lCoarseTune)
 232 {
 233     eax_validate_range<EaxPitchShifterEffectException>(
 234         "Coarse Tune",
 235         lCoarseTune,
 236         EAXPITCHSHIFTER_MINCOARSETUNE,
 237         EAXPITCHSHIFTER_MAXCOARSETUNE);
 238 }
 239
 240 void EaxPitchShifterEffect::validate_fine_tune(
 241     long lFineTune)
 242 {
 243     eax_validate_range<EaxPitchShifterEffectException>(
 244         "Fine Tune",
 245         lFineTune,
 246         EAXPITCHSHIFTER_MINFINETUNE,
 247         EAXPITCHSHIFTER_MAXFINETUNE);
 248 }
 249
 250 void EaxPitchShifterEffect::validate_all(
 251     const EAXPITCHSHIFTERPROPERTIES& all)
 252 {
 253     validate_coarse_tune(all.lCoarseTune);
 254     validate_fine_tune(all.lFineTune);
 255 }
 256
 257 void EaxPitchShifterEffect::defer_coarse_tune(
 258     long lCoarseTune)
 259 {
 260     eax_d_.lCoarseTune = lCoarseTune;
 261     eax_dirty_flags_.lCoarseTune = (eax_.lCoarseTune != eax_d_.lCoarseTune);
 262 }
 263
 264 void EaxPitchShifterEffect::defer_fine_tune(
 265     long lFineTune)
 266 {
 267     eax_d_.lFineTune = lFineTune;
 268     eax_dirty_flags_.lFineTune = (eax_.lFineTune != eax_d_.lFineTune);
 269 }
 270
 271 void EaxPitchShifterEffect::defer_all(
 272     const EAXPITCHSHIFTERPROPERTIES& all)
 273 {
 274     defer_coarse_tune(all.lCoarseTune);
 275     defer_fine_tune(all.lFineTune);
 276 }
 277
 278 void EaxPitchShifterEffect::defer_coarse_tune(
 279     const EaxEaxCall& eax_call)
 280 {
 281     const auto& coarse_tune =
 282         eax_call.get_value<EaxPitchShifterEffectException, const decltype(EAXPITCHSHIFTERPROPERTIES::lCoarseTune)>();
 283
 284     validate_coarse_tune(coarse_tune);
 285     defer_coarse_tune(coarse_tune);
 286 }
 287
 288 void EaxPitchShifterEffect::defer_fine_tune(
 289     const EaxEaxCall& eax_call)
 290 {
 291     const auto& fine_tune =
 292         eax_call.get_value<EaxPitchShifterEffectException, const decltype(EAXPITCHSHIFTERPROPERTIES::lFineTune)>();
 293
 294     validate_fine_tune(fine_tune);
 295     defer_fine_tune(fine_tune);
 296 }
 297
 298 void EaxPitchShifterEffect::defer_all(
 299     const EaxEaxCall& eax_call)
 300 {
 301     const auto& all =
 302         eax_call.get_value<EaxPitchShifterEffectException, const EAXPITCHSHIFTERPROPERTIES>();
 303
 304     validate_all(all);
 305     defer_all(all);
 306 }
 307
 308 // [[nodiscard]]
 309 bool EaxPitchShifterEffect::apply_deferred()
 310 {
 311     if (eax_dirty_flags_ == EaxPitchShifterEffectDirtyFlags{})
 312     {
 313         return false;
 314     }
 315
 316     eax_ = eax_d_;
 317
 318     if (eax_dirty_flags_.lCoarseTune)
 319     {
 320         set_efx_coarse_tune();
 321     }
 322
 323     if (eax_dirty_flags_.lFineTune)
 324     {
 325         set_efx_fine_tune();
 326     }
 327
 328     eax_dirty_flags_ = EaxPitchShifterEffectDirtyFlags{};
 329
 330     return true;
 331 }
 332
 333 void EaxPitchShifterEffect::set(const EaxEaxCall& eax_call)
 334 {
 335     switch(eax_call.get_property_id())
 336     {
 337         case EAXPITCHSHIFTER_NONE:
 338             break;
 339
 340         case EAXPITCHSHIFTER_ALLPARAMETERS:
 341             defer_all(eax_call);
 342             break;
 343
 344         case EAXPITCHSHIFTER_COARSETUNE:
 345             defer_coarse_tune(eax_call);
 346             break;
 347
 348         case EAXPITCHSHIFTER_FINETUNE:
 349             defer_fine_tune(eax_call);
 350             break;
 351
 352         default:
 353             throw EaxPitchShifterEffectException{"Unsupported property id."};
 354     }
 355 }
 356
 357 } // namespace
 358
 359 EaxEffectUPtr eax_create_eax_pitch_shifter_effect()
 360 {
 361     return std::make_unique<EaxPitchShifterEffect>();
 362 }
 363
 364 #endif // ALSOFT_EAX