🛠️🐜 Antkeeper superbuild with dependencies included
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
11 KiB
355 lines
11 KiB
|
|
#include "config.h"
|
|
|
|
#include "AL/al.h"
|
|
#include "AL/efx.h"
|
|
|
|
#include "alc/effects/base.h"
|
|
#include "effects.h"
|
|
|
|
#ifdef ALSOFT_EAX
|
|
#include "alnumeric.h"
|
|
#include "al/eax/exception.h"
|
|
#include "al/eax/utils.h"
|
|
#endif // ALSOFT_EAX
|
|
|
|
|
|
namespace {
|
|
|
|
void Distortion_setParami(EffectProps*, ALenum param, int)
|
|
{ throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param}; }
|
|
void Distortion_setParamiv(EffectProps*, ALenum param, const int*)
|
|
{
|
|
throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x",
|
|
param};
|
|
}
|
|
void Distortion_setParamf(EffectProps *props, ALenum param, float val)
|
|
{
|
|
switch(param)
|
|
{
|
|
case AL_DISTORTION_EDGE:
|
|
if(!(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE))
|
|
throw effect_exception{AL_INVALID_VALUE, "Distortion edge out of range"};
|
|
props->Distortion.Edge = val;
|
|
break;
|
|
|
|
case AL_DISTORTION_GAIN:
|
|
if(!(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN))
|
|
throw effect_exception{AL_INVALID_VALUE, "Distortion gain out of range"};
|
|
props->Distortion.Gain = val;
|
|
break;
|
|
|
|
case AL_DISTORTION_LOWPASS_CUTOFF:
|
|
if(!(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF))
|
|
throw effect_exception{AL_INVALID_VALUE, "Distortion low-pass cutoff out of range"};
|
|
props->Distortion.LowpassCutoff = val;
|
|
break;
|
|
|
|
case AL_DISTORTION_EQCENTER:
|
|
if(!(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER))
|
|
throw effect_exception{AL_INVALID_VALUE, "Distortion EQ center out of range"};
|
|
props->Distortion.EQCenter = val;
|
|
break;
|
|
|
|
case AL_DISTORTION_EQBANDWIDTH:
|
|
if(!(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH))
|
|
throw effect_exception{AL_INVALID_VALUE, "Distortion EQ bandwidth out of range"};
|
|
props->Distortion.EQBandwidth = val;
|
|
break;
|
|
|
|
default:
|
|
throw effect_exception{AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param};
|
|
}
|
|
}
|
|
void Distortion_setParamfv(EffectProps *props, ALenum param, const float *vals)
|
|
{ Distortion_setParamf(props, param, vals[0]); }
|
|
|
|
void Distortion_getParami(const EffectProps*, ALenum param, int*)
|
|
{ throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer property 0x%04x", param}; }
|
|
void Distortion_getParamiv(const EffectProps*, ALenum param, int*)
|
|
{
|
|
throw effect_exception{AL_INVALID_ENUM, "Invalid distortion integer-vector property 0x%04x",
|
|
param};
|
|
}
|
|
void Distortion_getParamf(const EffectProps *props, ALenum param, float *val)
|
|
{
|
|
switch(param)
|
|
{
|
|
case AL_DISTORTION_EDGE:
|
|
*val = props->Distortion.Edge;
|
|
break;
|
|
|
|
case AL_DISTORTION_GAIN:
|
|
*val = props->Distortion.Gain;
|
|
break;
|
|
|
|
case AL_DISTORTION_LOWPASS_CUTOFF:
|
|
*val = props->Distortion.LowpassCutoff;
|
|
break;
|
|
|
|
case AL_DISTORTION_EQCENTER:
|
|
*val = props->Distortion.EQCenter;
|
|
break;
|
|
|
|
case AL_DISTORTION_EQBANDWIDTH:
|
|
*val = props->Distortion.EQBandwidth;
|
|
break;
|
|
|
|
default:
|
|
throw effect_exception{AL_INVALID_ENUM, "Invalid distortion float property 0x%04x", param};
|
|
}
|
|
}
|
|
void Distortion_getParamfv(const EffectProps *props, ALenum param, float *vals)
|
|
{ Distortion_getParamf(props, param, vals); }
|
|
|
|
EffectProps genDefaultProps() noexcept
|
|
{
|
|
EffectProps props{};
|
|
props.Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE;
|
|
props.Distortion.Gain = AL_DISTORTION_DEFAULT_GAIN;
|
|
props.Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF;
|
|
props.Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER;
|
|
props.Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH;
|
|
return props;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
DEFINE_ALEFFECT_VTABLE(Distortion);
|
|
|
|
const EffectProps DistortionEffectProps{genDefaultProps()};
|
|
|
|
#ifdef ALSOFT_EAX
|
|
namespace {
|
|
|
|
class EaxDistortionEffectException : public EaxException
|
|
{
|
|
public:
|
|
explicit EaxDistortionEffectException(const char* message)
|
|
: EaxException{"EAX_DISTORTION_EFFECT", message}
|
|
{}
|
|
}; // EaxDistortionEffectException
|
|
|
|
class EaxDistortionEffect final : public EaxEffect4<EaxDistortionEffectException, EAXDISTORTIONPROPERTIES>
|
|
{
|
|
public:
|
|
EaxDistortionEffect(const EaxCall& call);
|
|
|
|
private:
|
|
struct EdgeValidator {
|
|
void operator()(float flEdge) const
|
|
{
|
|
eax_validate_range<Exception>(
|
|
"Edge",
|
|
flEdge,
|
|
EAXDISTORTION_MINEDGE,
|
|
EAXDISTORTION_MAXEDGE);
|
|
}
|
|
}; // EdgeValidator
|
|
|
|
struct GainValidator {
|
|
void operator()(long lGain) const
|
|
{
|
|
eax_validate_range<Exception>(
|
|
"Gain",
|
|
lGain,
|
|
EAXDISTORTION_MINGAIN,
|
|
EAXDISTORTION_MAXGAIN);
|
|
}
|
|
}; // GainValidator
|
|
|
|
struct LowPassCutOffValidator {
|
|
void operator()(float flLowPassCutOff) const
|
|
{
|
|
eax_validate_range<Exception>(
|
|
"Low-pass Cut-off",
|
|
flLowPassCutOff,
|
|
EAXDISTORTION_MINLOWPASSCUTOFF,
|
|
EAXDISTORTION_MAXLOWPASSCUTOFF);
|
|
}
|
|
}; // LowPassCutOffValidator
|
|
|
|
struct EqCenterValidator {
|
|
void operator()(float flEQCenter) const
|
|
{
|
|
eax_validate_range<Exception>(
|
|
"EQ Center",
|
|
flEQCenter,
|
|
EAXDISTORTION_MINEQCENTER,
|
|
EAXDISTORTION_MAXEQCENTER);
|
|
}
|
|
}; // EqCenterValidator
|
|
|
|
struct EqBandwidthValidator {
|
|
void operator()(float flEQBandwidth) const
|
|
{
|
|
eax_validate_range<Exception>(
|
|
"EQ Bandwidth",
|
|
flEQBandwidth,
|
|
EAXDISTORTION_MINEQBANDWIDTH,
|
|
EAXDISTORTION_MAXEQBANDWIDTH);
|
|
}
|
|
}; // EqBandwidthValidator
|
|
|
|
struct AllValidator {
|
|
void operator()(const Props& all) const
|
|
{
|
|
EdgeValidator{}(all.flEdge);
|
|
GainValidator{}(all.lGain);
|
|
LowPassCutOffValidator{}(all.flLowPassCutOff);
|
|
EqCenterValidator{}(all.flEQCenter);
|
|
EqBandwidthValidator{}(all.flEQBandwidth);
|
|
}
|
|
}; // AllValidator
|
|
|
|
void set_defaults(Props& props) override;
|
|
|
|
void set_efx_edge() noexcept;
|
|
void set_efx_gain() noexcept;
|
|
void set_efx_lowpass_cutoff() noexcept;
|
|
void set_efx_eq_center() noexcept;
|
|
void set_efx_eq_bandwidth() noexcept;
|
|
void set_efx_defaults() override;
|
|
|
|
void get(const EaxCall& call, const Props& props) override;
|
|
void set(const EaxCall& call, Props& props) override;
|
|
bool commit_props(const Props& props) override;
|
|
}; // EaxDistortionEffect
|
|
|
|
EaxDistortionEffect::EaxDistortionEffect(const EaxCall& call)
|
|
: EaxEffect4{AL_EFFECT_DISTORTION, call}
|
|
{}
|
|
|
|
void EaxDistortionEffect::set_defaults(Props& props)
|
|
{
|
|
props.flEdge = EAXDISTORTION_DEFAULTEDGE;
|
|
props.lGain = EAXDISTORTION_DEFAULTGAIN;
|
|
props.flLowPassCutOff = EAXDISTORTION_DEFAULTLOWPASSCUTOFF;
|
|
props.flEQCenter = EAXDISTORTION_DEFAULTEQCENTER;
|
|
props.flEQBandwidth = EAXDISTORTION_DEFAULTEQBANDWIDTH;
|
|
}
|
|
|
|
void EaxDistortionEffect::set_efx_edge() noexcept
|
|
{
|
|
al_effect_props_.Distortion.Edge = clamp(
|
|
props_.flEdge,
|
|
AL_DISTORTION_MIN_EDGE,
|
|
AL_DISTORTION_MAX_EDGE);
|
|
}
|
|
|
|
void EaxDistortionEffect::set_efx_gain() noexcept
|
|
{
|
|
al_effect_props_.Distortion.Gain = clamp(
|
|
level_mb_to_gain(static_cast<float>(props_.lGain)),
|
|
AL_DISTORTION_MIN_GAIN,
|
|
AL_DISTORTION_MAX_GAIN);
|
|
}
|
|
|
|
void EaxDistortionEffect::set_efx_lowpass_cutoff() noexcept
|
|
{
|
|
al_effect_props_.Distortion.LowpassCutoff = clamp(
|
|
props_.flLowPassCutOff,
|
|
AL_DISTORTION_MIN_LOWPASS_CUTOFF,
|
|
AL_DISTORTION_MAX_LOWPASS_CUTOFF);
|
|
}
|
|
|
|
void EaxDistortionEffect::set_efx_eq_center() noexcept
|
|
{
|
|
al_effect_props_.Distortion.EQCenter = clamp(
|
|
props_.flEQCenter,
|
|
AL_DISTORTION_MIN_EQCENTER,
|
|
AL_DISTORTION_MAX_EQCENTER);
|
|
}
|
|
|
|
void EaxDistortionEffect::set_efx_eq_bandwidth() noexcept
|
|
{
|
|
al_effect_props_.Distortion.EQBandwidth = clamp(
|
|
props_.flEdge,
|
|
AL_DISTORTION_MIN_EQBANDWIDTH,
|
|
AL_DISTORTION_MAX_EQBANDWIDTH);
|
|
}
|
|
|
|
void EaxDistortionEffect::set_efx_defaults()
|
|
{
|
|
set_efx_edge();
|
|
set_efx_gain();
|
|
set_efx_lowpass_cutoff();
|
|
set_efx_eq_center();
|
|
set_efx_eq_bandwidth();
|
|
}
|
|
|
|
void EaxDistortionEffect::get(const EaxCall& call, const Props& props)
|
|
{
|
|
switch(call.get_property_id())
|
|
{
|
|
case EAXDISTORTION_NONE: break;
|
|
case EAXDISTORTION_ALLPARAMETERS: call.set_value<Exception>(props); break;
|
|
case EAXDISTORTION_EDGE: call.set_value<Exception>(props.flEdge); break;
|
|
case EAXDISTORTION_GAIN: call.set_value<Exception>(props.lGain); break;
|
|
case EAXDISTORTION_LOWPASSCUTOFF: call.set_value<Exception>(props.flLowPassCutOff); break;
|
|
case EAXDISTORTION_EQCENTER: call.set_value<Exception>(props.flEQCenter); break;
|
|
case EAXDISTORTION_EQBANDWIDTH: call.set_value<Exception>(props.flEQBandwidth); break;
|
|
default: fail_unknown_property_id();
|
|
}
|
|
}
|
|
|
|
void EaxDistortionEffect::set(const EaxCall& call, Props& props)
|
|
{
|
|
switch(call.get_property_id())
|
|
{
|
|
case EAXDISTORTION_NONE: break;
|
|
case EAXDISTORTION_ALLPARAMETERS: defer<AllValidator>(call, props); break;
|
|
case EAXDISTORTION_EDGE: defer<EdgeValidator>(call, props.flEdge); break;
|
|
case EAXDISTORTION_GAIN: defer<GainValidator>(call, props.lGain); break;
|
|
case EAXDISTORTION_LOWPASSCUTOFF: defer<LowPassCutOffValidator>(call, props.flLowPassCutOff); break;
|
|
case EAXDISTORTION_EQCENTER: defer<EqCenterValidator>(call, props.flEQCenter); break;
|
|
case EAXDISTORTION_EQBANDWIDTH: defer<EqBandwidthValidator>(call, props.flEQBandwidth); break;
|
|
default: fail_unknown_property_id();
|
|
}
|
|
}
|
|
|
|
bool EaxDistortionEffect::commit_props(const Props& props)
|
|
{
|
|
auto is_dirty = false;
|
|
|
|
if (props_.flEdge != props.flEdge)
|
|
{
|
|
is_dirty = true;
|
|
set_efx_edge();
|
|
}
|
|
|
|
if (props_.lGain != props.lGain)
|
|
{
|
|
is_dirty = true;
|
|
set_efx_gain();
|
|
}
|
|
|
|
if (props_.flLowPassCutOff != props.flLowPassCutOff)
|
|
{
|
|
is_dirty = true;
|
|
set_efx_lowpass_cutoff();
|
|
}
|
|
|
|
if (props_.flEQCenter != props.flEQCenter)
|
|
{
|
|
is_dirty = true;
|
|
set_efx_eq_center();
|
|
}
|
|
|
|
if (props_.flEQBandwidth != props.flEQBandwidth)
|
|
{
|
|
is_dirty = true;
|
|
set_efx_eq_bandwidth();
|
|
}
|
|
|
|
return is_dirty;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
EaxEffectUPtr eax_create_eax_distortion_effect(const EaxCall& call)
|
|
{
|
|
return eax_create_eax4_effect<EaxDistortionEffect>(call);
|
|
}
|
|
|
|
#endif // ALSOFT_EAX
|