al/effects/modulator.cpp

   1
   2 #include "config.h"
   3
   4 #include <optional>
   5 #include <stdexcept>
   6
   7 #include "AL/al.h"
   8 #include "AL/efx.h"
   9
  10 #include "alc/effects/base.h"
  11 #include "effects.h"
  12
  13 #ifdef ALSOFT_EAX
  14 #include <cassert>
  15 #include "alnumeric.h"
  16 #include "al/eax/effect.h"
  17 #include "al/eax/exception.h"
  18 #include "al/eax/utils.h"
  19 #endif // ALSOFT_EAX
  20
  21
  22 namespace {
  23
  24 constexpr std::optional<ModulatorWaveform> WaveformFromEmum(ALenum value) noexcept
  25 {
  26     switch(value)
  27     {
  28     case AL_RING_MODULATOR_SINUSOID: return ModulatorWaveform::Sinusoid;
  29     case AL_RING_MODULATOR_SAWTOOTH: return ModulatorWaveform::Sawtooth;
  30     case AL_RING_MODULATOR_SQUARE: return ModulatorWaveform::Square;
  31     }
  32     return std::nullopt;
  33 }
  34 constexpr ALenum EnumFromWaveform(ModulatorWaveform type)
  35 {
  36     switch(type)
  37     {
  38     case ModulatorWaveform::Sinusoid: return AL_RING_MODULATOR_SINUSOID;
  39     case ModulatorWaveform::Sawtooth: return AL_RING_MODULATOR_SAWTOOTH;
  40     case ModulatorWaveform::Square: return AL_RING_MODULATOR_SQUARE;
  41     }
  42     throw std::runtime_error{"Invalid modulator waveform: " +
  43         std::to_string(static_cast<int>(type))};
  44 }
  45
  46 constexpr EffectProps genDefaultProps() noexcept
  47 {
  48     ModulatorProps props{};
  49     props.Frequency      = AL_RING_MODULATOR_DEFAULT_FREQUENCY;
  50     props.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF;
  51     props.Waveform       = WaveformFromEmum(AL_RING_MODULATOR_DEFAULT_WAVEFORM).value();
  52     return props;
  53 }
  54
  55 } // namespace
  56
  57 const EffectProps ModulatorEffectProps{genDefaultProps()};
  58
  59 void ModulatorEffectHandler::SetParami(ModulatorProps &props, ALenum param, int val)
  60 {
  61     switch(param)
  62     {
  63     case AL_RING_MODULATOR_FREQUENCY:
  64     case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
  65         SetParamf(props, param, static_cast<float>(val));
  66         break;
  67
  68     case AL_RING_MODULATOR_WAVEFORM:
  69         if(auto formopt = WaveformFromEmum(val))
  70             props.Waveform = *formopt;
  71         else
  72             throw effect_exception{AL_INVALID_VALUE, "Invalid modulator waveform: 0x%04x", val};
  73         break;
  74
  75     default:
  76         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x",
  77             param};
  78     }
  79 }
  80 void ModulatorEffectHandler::SetParamiv(ModulatorProps &props, ALenum param, const int *vals)
  81 { SetParami(props, param, *vals); }
  82
  83 void ModulatorEffectHandler::SetParamf(ModulatorProps &props, ALenum param, float val)
  84 {
  85     switch(param)
  86     {
  87     case AL_RING_MODULATOR_FREQUENCY:
  88         if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
  89             throw effect_exception{AL_INVALID_VALUE, "Modulator frequency out of range: %f", val};
  90         props.Frequency = val;
  91         break;
  92
  93     case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
  94         if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF))
  95             throw effect_exception{AL_INVALID_VALUE, "Modulator high-pass cutoff out of range: %f", val};
  96         props.HighPassCutoff = val;
  97         break;
  98
  99     default:
 100         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param};
 101     }
 102 }
 103 void ModulatorEffectHandler::SetParamfv(ModulatorProps &props, ALenum param, const float *vals)
 104 { SetParamf(props, param, *vals); }
 105
 106 void ModulatorEffectHandler::GetParami(const ModulatorProps &props, ALenum param, int *val)
 107 {
 108     switch(param)
 109     {
 110     case AL_RING_MODULATOR_FREQUENCY: *val = static_cast<int>(props.Frequency); break;
 111     case AL_RING_MODULATOR_HIGHPASS_CUTOFF: *val = static_cast<int>(props.HighPassCutoff); break;
 112     case AL_RING_MODULATOR_WAVEFORM: *val = EnumFromWaveform(props.Waveform); break;
 113
 114     default:
 115         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator integer property 0x%04x",
 116             param};
 117     }
 118 }
 119 void ModulatorEffectHandler::GetParamiv(const ModulatorProps &props, ALenum param, int *vals)
 120 { GetParami(props, param, vals); }
 121 void ModulatorEffectHandler::GetParamf(const ModulatorProps &props, ALenum param, float *val)
 122 {
 123     switch(param)
 124     {
 125     case AL_RING_MODULATOR_FREQUENCY: *val = props.Frequency; break;
 126     case AL_RING_MODULATOR_HIGHPASS_CUTOFF: *val = props.HighPassCutoff; break;
 127
 128     default:
 129         throw effect_exception{AL_INVALID_ENUM, "Invalid modulator float property 0x%04x", param};
 130     }
 131 }
 132 void ModulatorEffectHandler::GetParamfv(const ModulatorProps &props, ALenum param, float *vals)
 133 { GetParamf(props, param, vals); }
 134
 135
 136 #ifdef ALSOFT_EAX
 137 namespace {
 138
 139 using ModulatorCommitter = EaxCommitter<EaxModulatorCommitter>;
 140
 141 struct FrequencyValidator {
 142     void operator()(float flFrequency) const
 143     {
 144         eax_validate_range<ModulatorCommitter::Exception>(
 145             "Frequency",
 146             flFrequency,
 147             EAXRINGMODULATOR_MINFREQUENCY,
 148             EAXRINGMODULATOR_MAXFREQUENCY);
 149     }
 150 }; // FrequencyValidator
 151
 152 struct HighPassCutOffValidator {
 153     void operator()(float flHighPassCutOff) const
 154     {
 155         eax_validate_range<ModulatorCommitter::Exception>(
 156             "High-Pass Cutoff",
 157             flHighPassCutOff,
 158             EAXRINGMODULATOR_MINHIGHPASSCUTOFF,
 159             EAXRINGMODULATOR_MAXHIGHPASSCUTOFF);
 160     }
 161 }; // HighPassCutOffValidator
 162
 163 struct WaveformValidator {
 164     void operator()(unsigned long ulWaveform) const
 165     {
 166         eax_validate_range<ModulatorCommitter::Exception>(
 167             "Waveform",
 168             ulWaveform,
 169             EAXRINGMODULATOR_MINWAVEFORM,
 170             EAXRINGMODULATOR_MAXWAVEFORM);
 171     }
 172 }; // WaveformValidator
 173
 174 struct AllValidator {
 175     void operator()(const EAXRINGMODULATORPROPERTIES& all) const
 176     {
 177         FrequencyValidator{}(all.flFrequency);
 178         HighPassCutOffValidator{}(all.flHighPassCutOff);
 179         WaveformValidator{}(all.ulWaveform);
 180     }
 181 }; // AllValidator
 182
 183 } // namespace
 184
 185 template<>
 186 struct ModulatorCommitter::Exception : public EaxException {
 187     explicit Exception(const char *message) : EaxException{"EAX_RING_MODULATOR_EFFECT", message}
 188     { }
 189 };
 190
 191 template<>
 192 [[noreturn]] void ModulatorCommitter::fail(const char *message)
 193 {
 194     throw Exception{message};
 195 }
 196
 197 bool EaxModulatorCommitter::commit(const EAXRINGMODULATORPROPERTIES &props)
 198 {
 199     if(auto *cur = std::get_if<EAXRINGMODULATORPROPERTIES>(&mEaxProps); cur && *cur == props)
 200         return false;
 201
 202     mEaxProps = props;
 203
 204     auto get_waveform = [](unsigned long form)
 205     {
 206         if(form == EAX_RINGMODULATOR_SINUSOID)
 207             return ModulatorWaveform::Sinusoid;
 208         if(form == EAX_RINGMODULATOR_SAWTOOTH)
 209             return ModulatorWaveform::Sawtooth;
 210         if(form == EAX_RINGMODULATOR_SQUARE)
 211             return ModulatorWaveform::Square;
 212         return ModulatorWaveform::Sinusoid;
 213     };
 214
 215     mAlProps = [&]{
 216         ModulatorProps ret{};
 217         ret.Frequency = props.flFrequency;
 218         ret.HighPassCutoff = props.flHighPassCutOff;
 219         ret.Waveform = get_waveform(props.ulWaveform);
 220         return ret;
 221     }();
 222
 223     return true;
 224 }
 225
 226 void EaxModulatorCommitter::SetDefaults(EaxEffectProps &props)
 227 {
 228     static constexpr EAXRINGMODULATORPROPERTIES defprops{[]
 229     {
 230         EAXRINGMODULATORPROPERTIES ret{};
 231         ret.flFrequency = EAXRINGMODULATOR_DEFAULTFREQUENCY;
 232         ret.flHighPassCutOff = EAXRINGMODULATOR_DEFAULTHIGHPASSCUTOFF;
 233         ret.ulWaveform = EAXRINGMODULATOR_DEFAULTWAVEFORM;
 234         return ret;
 235     }()};
 236     props = defprops;
 237 }
 238
 239 void EaxModulatorCommitter::Get(const EaxCall &call, const EAXRINGMODULATORPROPERTIES &props)
 240 {
 241     switch(call.get_property_id())
 242     {
 243     case EAXRINGMODULATOR_NONE: break;
 244     case EAXRINGMODULATOR_ALLPARAMETERS: call.set_value<Exception>(props); break;
 245     case EAXRINGMODULATOR_FREQUENCY: call.set_value<Exception>(props.flFrequency); break;
 246     case EAXRINGMODULATOR_HIGHPASSCUTOFF: call.set_value<Exception>(props.flHighPassCutOff); break;
 247     case EAXRINGMODULATOR_WAVEFORM: call.set_value<Exception>(props.ulWaveform); break;
 248     default: fail_unknown_property_id();
 249     }
 250 }
 251
 252 void EaxModulatorCommitter::Set(const EaxCall &call, EAXRINGMODULATORPROPERTIES &props)
 253 {
 254     switch(call.get_property_id())
 255     {
 256     case EAXRINGMODULATOR_NONE: break;
 257     case EAXRINGMODULATOR_ALLPARAMETERS: defer<AllValidator>(call, props); break;
 258     case EAXRINGMODULATOR_FREQUENCY: defer<FrequencyValidator>(call, props.flFrequency); break;
 259     case EAXRINGMODULATOR_HIGHPASSCUTOFF: defer<HighPassCutOffValidator>(call, props.flHighPassCutOff); break;
 260     case EAXRINGMODULATOR_WAVEFORM: defer<WaveformValidator>(call, props.ulWaveform); break;
 261     default: fail_unknown_property_id();
 262     }
 263 }
 264
 265 #endif // ALSOFT_EAX