aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Alc/alc.cpp18
-rw-r--r--Alc/alu.cpp18
-rw-r--r--Alc/effects/autowah.cpp116
-rw-r--r--Alc/effects/chorus.cpp135
-rw-r--r--Alc/effects/compressor.cpp75
-rw-r--r--Alc/effects/dedicated.cpp69
-rw-r--r--Alc/effects/distortion.cpp67
-rw-r--r--Alc/effects/echo.cpp99
-rw-r--r--Alc/effects/equalizer.cpp93
-rw-r--r--Alc/effects/fshifter.cpp118
-rw-r--r--Alc/effects/modulator.cpp85
-rw-r--r--Alc/effects/null.cpp69
-rw-r--r--Alc/effects/pshifter.cpp147
-rw-r--r--Alc/effects/reverb.cpp316
-rw-r--r--OpenAL32/Include/alAuxEffectSlot.h59
-rw-r--r--OpenAL32/Include/alMain.h3
-rw-r--r--OpenAL32/alAuxEffectSlot.cpp59
-rw-r--r--OpenAL32/event.cpp2
18 files changed, 626 insertions, 922 deletions
diff --git a/Alc/alc.cpp b/Alc/alc.cpp
index 6e68d130..56a581fd 100644
--- a/Alc/alc.cpp
+++ b/Alc/alc.cpp
@@ -2256,11 +2256,11 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
if(context->DefaultSlot)
{
ALeffectslot *slot = context->DefaultSlot;
- ALeffectState *state = slot->Effect.State;
+ EffectState *state = slot->Effect.State;
- state->OutBuffer = device->Dry.Buffer;
- state->OutChannels = device->Dry.NumChannels;
- if(V(state,deviceUpdate)(device) == AL_FALSE)
+ state->mOutBuffer = device->Dry.Buffer;
+ state->mOutChannels = device->Dry.NumChannels;
+ if(state->deviceUpdate(device) == AL_FALSE)
update_failed = AL_TRUE;
else
UpdateEffectSlotProps(slot, context);
@@ -2270,11 +2270,11 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
almtx_lock(&context->EffectSlotLock);
for(auto &slot : context->EffectSlotList)
{
- ALeffectState *state = slot->Effect.State;
+ EffectState *state = slot->Effect.State;
- state->OutBuffer = device->Dry.Buffer;
- state->OutChannels = device->Dry.NumChannels;
- if(V(state,deviceUpdate)(device) == AL_FALSE)
+ state->mOutBuffer = device->Dry.Buffer;
+ state->mOutChannels = device->Dry.NumChannels;
+ if(state->deviceUpdate(device) == AL_FALSE)
update_failed = AL_TRUE;
else
UpdateEffectSlotProps(slot, context);
@@ -2603,7 +2603,7 @@ ALCcontext_struct::~ALCcontext_struct()
while(eprops)
{
struct ALeffectslotProps *next{eprops->next.load(std::memory_order_relaxed)};
- if(eprops->State) ALeffectState_DecRef(eprops->State);
+ if(eprops->State) eprops->State->DecRef();
al_free(eprops);
eprops = next;
++count;
diff --git a/Alc/alu.cpp b/Alc/alu.cpp
index e30f6a2e..6a2f0c01 100644
--- a/Alc/alu.cpp
+++ b/Alc/alu.cpp
@@ -381,7 +381,7 @@ static bool CalcListenerParams(ALCcontext *Context)
static bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context, bool force)
{
struct ALeffectslotProps *props;
- ALeffectState *state;
+ EffectState *state;
props = slot->Update.exchange(nullptr, std::memory_order_acq_rel);
if(!props && !force) return false;
@@ -419,8 +419,8 @@ static bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context, bool f
* count safely to remove it from the update object (it can't reach
* 0 refs since the current params also hold a reference).
*/
- DecrementRef(&state->Ref);
- props->State = NULL;
+ DecrementRef(&state->mRef);
+ props->State = nullptr;
}
else
{
@@ -428,7 +428,7 @@ static bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context, bool f
* event.
*/
AsyncEvent evt = ASYNC_EVENT(EventType_ReleaseEffectState);
- evt.u.EffectState = slot->Params.EffectState;
+ evt.u.mEffectState = slot->Params.EffectState;
slot->Params.EffectState = state;
props->State = NULL;
@@ -442,7 +442,7 @@ static bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context, bool f
* eventually be cleaned up sometime later (not ideal, but
* better than blocking or leaking).
*/
- props->State = evt.u.EffectState;
+ props->State = evt.u.mEffectState;
}
}
@@ -451,7 +451,7 @@ static bool CalcEffectSlotParams(ALeffectslot *slot, ALCcontext *context, bool f
else
state = slot->Params.EffectState;
- V(state,update)(context, slot, &slot->Params.EffectProps);
+ state->update(context, slot, &slot->Params.EffectProps);
return true;
}
@@ -1749,9 +1749,9 @@ void aluMixData(ALCdevice *device, ALvoid *OutBuffer, ALsizei NumSamples)
for(i = 0;i < auxslots->count;i++)
{
const ALeffectslot *slot = auxslots->slot[i];
- ALeffectState *state = slot->Params.EffectState;
- V(state,process)(SamplesToDo, slot->WetBuffer, state->OutBuffer,
- state->OutChannels);
+ EffectState *state = slot->Params.EffectState;
+ state->process(SamplesToDo, slot->WetBuffer, state->mOutBuffer,
+ state->mOutChannels);
}
ctx = ATOMIC_LOAD(&ctx->next, almemory_order_relaxed);
diff --git a/Alc/effects/autowah.cpp b/Alc/effects/autowah.cpp
index 4cf79998..8e789652 100644
--- a/Alc/effects/autowah.cpp
+++ b/Alc/effects/autowah.cpp
@@ -37,7 +37,7 @@
#define MAX_FREQ 2500.0f
#define Q_FACTOR 5.0f
-struct ALautowahState final : public ALeffectState {
+struct ALautowahState final : public EffectState {
/* Effect parameters */
ALfloat mAttackRate;
ALfloat mReleaseRate;
@@ -66,48 +66,34 @@ struct ALautowahState final : public ALeffectState {
/* Effects buffers */
alignas(16) ALfloat mBufferOut[BUFFERSIZE];
-};
-static ALvoid ALautowahState_Destruct(ALautowahState *state);
-static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *device);
-static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALautowahState)
-DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState);
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static void ALautowahState_Construct(ALautowahState *state)
-{
- new (state) ALautowahState{};
- ALeffectState_Construct(state);
- SET_VTABLE2(ALautowahState, ALeffectState, state);
-}
-
-static ALvoid ALautowahState_Destruct(ALautowahState *state)
-{
- ALeffectState_Destruct(state);
- state->~ALautowahState();
-}
+ DEF_NEWDEL(ALautowahState)
+};
-static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *UNUSED(device))
+ALboolean ALautowahState::deviceUpdate(ALCdevice *UNUSED(device))
{
/* (Re-)initializing parameters and clear the buffers. */
- state->mAttackRate = 1.0f;
- state->mReleaseRate = 1.0f;
- state->mResonanceGain = 10.0f;
- state->mPeakGain = 4.5f;
- state->mFreqMinNorm = 4.5e-4f;
- state->mBandwidthNorm = 0.05f;
- state->mEnvDelay = 0.0f;
+ mAttackRate = 1.0f;
+ mReleaseRate = 1.0f;
+ mResonanceGain = 10.0f;
+ mPeakGain = 4.5f;
+ mFreqMinNorm = 4.5e-4f;
+ mBandwidthNorm = 0.05f;
+ mEnvDelay = 0.0f;
- for(auto &e : state->mEnv)
+ for(auto &e : mEnv)
{
e.cos_w0 = 0.0f;
e.alpha = 0.0f;
}
- for(auto &chan : state->mChans)
+ for(auto &chan : mChans)
{
std::fill(std::begin(chan.CurrentGains), std::end(chan.CurrentGains), 0.0f);
chan.Filter.z1 = 0.0f;
@@ -117,7 +103,7 @@ static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *U
return AL_TRUE;
}
-static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALautowahState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALfloat ReleaseTime;
@@ -125,33 +111,33 @@ static ALvoid ALautowahState_update(ALautowahState *state, const ALCcontext *con
ReleaseTime = clampf(props->Autowah.ReleaseTime, 0.001f, 1.0f);
- state->mAttackRate = expf(-1.0f / (props->Autowah.AttackTime*device->Frequency));
- state->mReleaseRate = expf(-1.0f / (ReleaseTime*device->Frequency));
+ mAttackRate = expf(-1.0f / (props->Autowah.AttackTime*device->Frequency));
+ mReleaseRate = expf(-1.0f / (ReleaseTime*device->Frequency));
/* 0-20dB Resonance Peak gain */
- state->mResonanceGain = sqrtf(log10f(props->Autowah.Resonance)*10.0f / 3.0f);
- state->mPeakGain = 1.0f - log10f(props->Autowah.PeakGain/AL_AUTOWAH_MAX_PEAK_GAIN);
- state->mFreqMinNorm = MIN_FREQ / device->Frequency;
- state->mBandwidthNorm = (MAX_FREQ-MIN_FREQ) / device->Frequency;
+ mResonanceGain = sqrtf(log10f(props->Autowah.Resonance)*10.0f / 3.0f);
+ mPeakGain = 1.0f - log10f(props->Autowah.PeakGain/AL_AUTOWAH_MAX_PEAK_GAIN);
+ mFreqMinNorm = MIN_FREQ / device->Frequency;
+ mBandwidthNorm = (MAX_FREQ-MIN_FREQ) / device->Frequency;
- state->OutBuffer = device->FOAOut.Buffer;
- state->OutChannels = device->FOAOut.NumChannels;
+ mOutBuffer = device->FOAOut.Buffer;
+ mOutChannels = device->FOAOut.NumChannels;
for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
ComputePanGains(&device->FOAOut, aluMatrixf::Identity.m[i], slot->Params.Gain,
- state->mChans[i].TargetGains);
+ mChans[i].TargetGains);
}
-static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALautowahState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- const ALfloat attack_rate = state->mAttackRate;
- const ALfloat release_rate = state->mReleaseRate;
- const ALfloat res_gain = state->mResonanceGain;
- const ALfloat peak_gain = state->mPeakGain;
- const ALfloat freq_min = state->mFreqMinNorm;
- const ALfloat bandwidth = state->mBandwidthNorm;
+ const ALfloat attack_rate = mAttackRate;
+ const ALfloat release_rate = mReleaseRate;
+ const ALfloat res_gain = mResonanceGain;
+ const ALfloat peak_gain = mPeakGain;
+ const ALfloat freq_min = mFreqMinNorm;
+ const ALfloat bandwidth = mBandwidthNorm;
ALfloat env_delay;
ALsizei c, i;
- env_delay = state->mEnvDelay;
+ env_delay = mEnvDelay;
for(i = 0;i < SamplesToDo;i++)
{
ALfloat w0, sample, a;
@@ -165,10 +151,10 @@ static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo,
/* Calculate the cos and alpha components for this sample's filter. */
w0 = minf((bandwidth*env_delay + freq_min), 0.46f) * F_TAU;
- state->mEnv[i].cos_w0 = cosf(w0);
- state->mEnv[i].alpha = sinf(w0)/(2.0f * Q_FACTOR);
+ mEnv[i].cos_w0 = cosf(w0);
+ mEnv[i].alpha = sinf(w0)/(2.0f * Q_FACTOR);
}
- state->mEnvDelay = env_delay;
+ mEnvDelay = env_delay;
for(c = 0;c < MAX_EFFECT_CHANNELS; c++)
{
@@ -178,13 +164,13 @@ static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo,
* envelope. Because the filter changes for each sample, the
* coefficients are transient and don't need to be held.
*/
- ALfloat z1 = state->mChans[c].Filter.z1;
- ALfloat z2 = state->mChans[c].Filter.z2;
+ ALfloat z1 = mChans[c].Filter.z1;
+ ALfloat z2 = mChans[c].Filter.z2;
for(i = 0;i < SamplesToDo;i++)
{
- const ALfloat alpha = state->mEnv[i].alpha;
- const ALfloat cos_w0 = state->mEnv[i].cos_w0;
+ const ALfloat alpha = mEnv[i].alpha;
+ const ALfloat cos_w0 = mEnv[i].cos_w0;
ALfloat input, output;
ALfloat a[3], b[3];
@@ -199,27 +185,23 @@ static ALvoid ALautowahState_process(ALautowahState *state, ALsizei SamplesToDo,
output = input*(b[0]/a[0]) + z1;
z1 = input*(b[1]/a[0]) - output*(a[1]/a[0]) + z2;
z2 = input*(b[2]/a[0]) - output*(a[2]/a[0]);
- state->mBufferOut[i] = output;
+ mBufferOut[i] = output;
}
- state->mChans[c].Filter.z1 = z1;
- state->mChans[c].Filter.z2 = z2;
+ mChans[c].Filter.z1 = z1;
+ mChans[c].Filter.z2 = z2;
/* Now, mix the processed sound data to the output. */
- MixSamples(state->mBufferOut, NumChannels, SamplesOut, state->mChans[c].CurrentGains,
- state->mChans[c].TargetGains, SamplesToDo, 0, SamplesToDo);
+ MixSamples(mBufferOut, NumChannels, SamplesOut, mChans[c].CurrentGains,
+ mChans[c].TargetGains, SamplesToDo, 0, SamplesToDo);
}
}
struct AutowahStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *AutowahStateFactory::create()
-{
- ALautowahState *state;
- NEW_OBJ0(state, ALautowahState)();
- return state;
-}
+EffectState *AutowahStateFactory::create()
+{ return new ALautowahState{}; }
EffectStateFactory *AutowahStateFactory_getFactory(void)
{
diff --git a/Alc/effects/chorus.cpp b/Alc/effects/chorus.cpp
index d859d630..ee0b64e5 100644
--- a/Alc/effects/chorus.cpp
+++ b/Alc/effects/chorus.cpp
@@ -42,7 +42,7 @@ enum WaveForm {
WF_Triangle
};
-struct ALchorusState final : public ALeffectState {
+struct ALchorusState final : public EffectState {
al::vector<ALfloat,16> mSampleBuffer;
ALsizei mOffset{0};
@@ -62,31 +62,16 @@ struct ALchorusState final : public ALeffectState {
ALint mDelay{0};
ALfloat mDepth{0.0f};
ALfloat mFeedback{0.0f};
-};
-
-static ALvoid ALchorusState_Destruct(ALchorusState *state);
-static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device);
-static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props);
-static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALchorusState)
-DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState);
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static void ALchorusState_Construct(ALchorusState *state)
-{
- new (state) ALchorusState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALchorusState, ALeffectState, state);
-}
-
-static ALvoid ALchorusState_Destruct(ALchorusState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALchorusState();
-}
+ DEF_NEWDEL(ALchorusState)
+};
-static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device)
+ALboolean ALchorusState::deviceUpdate(ALCdevice *Device)
{
const ALfloat max_delay = maxf(AL_CHORUS_MAX_DELAY, AL_FLANGER_MAX_DELAY);
size_t maxlen;
@@ -94,14 +79,14 @@ static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Dev
maxlen = NextPowerOf2(float2int(max_delay*2.0f*Device->Frequency) + 1u);
if(maxlen <= 0) return AL_FALSE;
- if(maxlen != state->mSampleBuffer.size())
+ if(maxlen != mSampleBuffer.size())
{
- state->mSampleBuffer.resize(maxlen);
- state->mSampleBuffer.shrink_to_fit();
+ mSampleBuffer.resize(maxlen);
+ mSampleBuffer.shrink_to_fit();
}
- std::fill(state->mSampleBuffer.begin(), state->mSampleBuffer.end(), 0.0f);
- for(auto &e : state->mGains)
+ std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), 0.0f);
+ for(auto &e : mGains)
{
std::fill(std::begin(e.Current), std::end(e.Current), 0.0f);
std::fill(std::begin(e.Target), std::end(e.Target), 0.0f);
@@ -110,7 +95,7 @@ static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Dev
return AL_TRUE;
}
-static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props)
+void ALchorusState::update(const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props)
{
const ALsizei mindelay = MAX_RESAMPLE_PADDING << FRACTIONBITS;
const ALCdevice *device = Context->Device;
@@ -122,37 +107,35 @@ static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Conte
switch(props->Chorus.Waveform)
{
case AL_CHORUS_WAVEFORM_TRIANGLE:
- state->mWaveform = WF_Triangle;
+ mWaveform = WF_Triangle;
break;
case AL_CHORUS_WAVEFORM_SINUSOID:
- state->mWaveform = WF_Sinusoid;
+ mWaveform = WF_Sinusoid;
break;
}
/* The LFO depth is scaled to be relative to the sample delay. Clamp the
* delay and depth to allow enough padding for resampling.
*/
- state->mDelay = maxi(float2int(props->Chorus.Delay*frequency*FRACTIONONE + 0.5f),
- mindelay);
- state->mDepth = minf(props->Chorus.Depth * state->mDelay,
- (ALfloat)(state->mDelay - mindelay));
+ mDelay = maxi(float2int(props->Chorus.Delay*frequency*FRACTIONONE + 0.5f), mindelay);
+ mDepth = minf(props->Chorus.Depth * mDelay, (ALfloat)(mDelay - mindelay));
- state->mFeedback = props->Chorus.Feedback;
+ mFeedback = props->Chorus.Feedback;
/* Gains for left and right sides */
CalcAngleCoeffs(-F_PI_2, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, Slot->Params.Gain, state->mGains[0].Target);
+ ComputePanGains(&device->Dry, coeffs, Slot->Params.Gain, mGains[0].Target);
CalcAngleCoeffs( F_PI_2, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, Slot->Params.Gain, state->mGains[1].Target);
+ ComputePanGains(&device->Dry, coeffs, Slot->Params.Gain, mGains[1].Target);
phase = props->Chorus.Phase;
rate = props->Chorus.Rate;
if(!(rate > 0.0f))
{
- state->mLfoOffset = 0;
- state->mLfoRange = 1;
- state->mLfoScale = 0.0f;
- state->mLfoDisp = 0;
+ mLfoOffset = 0;
+ mLfoRange = 1;
+ mLfoScale = 0.0f;
+ mLfoDisp = 0;
}
else
{
@@ -161,22 +144,21 @@ static ALvoid ALchorusState_update(ALchorusState *state, const ALCcontext *Conte
*/
ALsizei lfo_range = float2int(minf(frequency/rate + 0.5f, (ALfloat)(INT_MAX/360 - 180)));
- state->mLfoOffset = float2int((ALfloat)state->mLfoOffset/state->mLfoRange*
- lfo_range + 0.5f) % lfo_range;
- state->mLfoRange = lfo_range;
- switch(state->mWaveform)
+ mLfoOffset = float2int((ALfloat)mLfoOffset/mLfoRange*lfo_range + 0.5f) % lfo_range;
+ mLfoRange = lfo_range;
+ switch(mWaveform)
{
case WF_Triangle:
- state->mLfoScale = 4.0f / state->mLfoRange;
+ mLfoScale = 4.0f / mLfoRange;
break;
case WF_Sinusoid:
- state->mLfoScale = F_TAU / state->mLfoRange;
+ mLfoScale = F_TAU / mLfoRange;
break;
}
/* Calculate lfo phase displacement */
if(phase < 0) phase = 360 + phase;
- state->mLfoDisp = (state->mLfoRange*phase + 180) / 360;
+ mLfoDisp = (mLfoRange*phase + 180) / 360;
}
}
@@ -204,14 +186,13 @@ static void GetSinusoidDelays(ALint *RESTRICT delays, ALsizei offset, const ALsi
}
}
-
-static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALchorusState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- const ALsizei bufmask = state->mSampleBuffer.size()-1;
- const ALfloat feedback = state->mFeedback;
- const ALsizei avgdelay = (state->mDelay + (FRACTIONONE>>1)) >> FRACTIONBITS;
- ALfloat *RESTRICT delaybuf = state->mSampleBuffer.data();
- ALsizei offset = state->mOffset;
+ const ALsizei bufmask = mSampleBuffer.size()-1;
+ const ALfloat feedback = mFeedback;
+ const ALsizei avgdelay = (mDelay + (FRACTIONONE>>1)) >> FRACTIONBITS;
+ ALfloat *RESTRICT delaybuf = mSampleBuffer.data();
+ ALsizei offset = mOffset;
ALsizei i, c;
ALsizei base;
@@ -221,23 +202,21 @@ static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, c
ALint moddelays[2][256];
alignas(16) ALfloat temps[2][256];
- if(state->mWaveform == WF_Sinusoid)
+ if(mWaveform == WF_Sinusoid)
{
- GetSinusoidDelays(moddelays[0], state->mLfoOffset, state->mLfoRange, state->mLfoScale,
- state->mDepth, state->mDelay, todo);
- GetSinusoidDelays(moddelays[1], (state->mLfoOffset+state->mLfoDisp)%state->mLfoRange,
- state->mLfoRange, state->mLfoScale, state->mDepth, state->mDelay,
+ GetSinusoidDelays(moddelays[0], mLfoOffset, mLfoRange, mLfoScale, mDepth, mDelay,
todo);
+ GetSinusoidDelays(moddelays[1], (mLfoOffset+mLfoDisp)%mLfoRange, mLfoRange, mLfoScale,
+ mDepth, mDelay, todo);
}
else /*if(state->waveform == WF_Triangle)*/
{
- GetTriangleDelays(moddelays[0], state->mLfoOffset, state->mLfoRange, state->mLfoScale,
- state->mDepth, state->mDelay, todo);
- GetTriangleDelays(moddelays[1], (state->mLfoOffset+state->mLfoDisp)%state->mLfoRange,
- state->mLfoRange, state->mLfoScale, state->mDepth, state->mDelay,
+ GetTriangleDelays(moddelays[0], mLfoOffset, mLfoRange, mLfoScale, mDepth, mDelay,
todo);
+ GetTriangleDelays(moddelays[1], (mLfoOffset+mLfoDisp)%mLfoRange, mLfoRange, mLfoScale,
+ mDepth, mDelay, todo);
}
- state->mLfoOffset = (state->mLfoOffset+todo) % state->mLfoRange;
+ mLfoOffset = (mLfoOffset+todo) % mLfoRange;
for(i = 0;i < todo;i++)
{
@@ -267,26 +246,22 @@ static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, c
}
for(c = 0;c < 2;c++)
- MixSamples(temps[c], NumChannels, SamplesOut, state->mGains[c].Current,
- state->mGains[c].Target, SamplesToDo-base, base, todo);
+ MixSamples(temps[c], NumChannels, SamplesOut, mGains[c].Current,
+ mGains[c].Target, SamplesToDo-base, base, todo);
base += todo;
}
- state->mOffset = offset;
+ mOffset = offset;
}
struct ChorusStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *ChorusStateFactory::create()
-{
- ALchorusState *state;
- NEW_OBJ0(state, ALchorusState)();
- return state;
-}
+EffectState *ChorusStateFactory::create()
+{ return new ALchorusState{}; }
EffectStateFactory *ChorusStateFactory_getFactory(void)
{
@@ -408,15 +383,11 @@ DEFINE_ALEFFECT_VTABLE(ALchorus);
* the same processing functions, so piggyback flanger on the chorus functions.
*/
struct FlangerStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *FlangerStateFactory::create()
-{
- ALchorusState *state;
- NEW_OBJ0(state, ALchorusState)();
- return state;
-}
+EffectState *FlangerStateFactory::create()
+{ return new ALchorusState{}; }
EffectStateFactory *FlangerStateFactory_getFactory(void)
{
diff --git a/Alc/effects/compressor.cpp b/Alc/effects/compressor.cpp
index be91dd6c..c8bdef15 100644
--- a/Alc/effects/compressor.cpp
+++ b/Alc/effects/compressor.cpp
@@ -37,7 +37,7 @@
#define RELEASE_TIME 0.2f /* 200ms to drop from max to min */
-struct ALcompressorState final : public ALeffectState {
+struct ALcompressorState final : public EffectState {
/* Effect gains for each channel */
ALfloat mGain[MAX_EFFECT_CHANNELS][MAX_OUTPUT_CHANNELS]{};
@@ -46,31 +46,16 @@ struct ALcompressorState final : public ALeffectState {
ALfloat mAttackMult{1.0f};
ALfloat mReleaseMult{1.0f};
ALfloat mEnvFollower{1.0f};
-};
-
-static ALvoid ALcompressorState_Destruct(ALcompressorState *state);
-static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device);
-static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALcompressorState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState);
-static void ALcompressorState_Construct(ALcompressorState *state)
-{
- new (state) ALcompressorState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALcompressorState, ALeffectState, state);
-}
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static ALvoid ALcompressorState_Destruct(ALcompressorState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALcompressorState();
-}
+ DEF_NEWDEL(ALcompressorState)
+};
-static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device)
+ALboolean ALcompressorState::deviceUpdate(ALCdevice *device)
{
/* Number of samples to do a full attack and release (non-integer sample
* counts are okay).
@@ -81,27 +66,25 @@ static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdev
/* Calculate per-sample multipliers to attack and release at the desired
* rates.
*/
- state->mAttackMult = powf(AMP_ENVELOPE_MAX/AMP_ENVELOPE_MIN, 1.0f/attackCount);
- state->mReleaseMult = powf(AMP_ENVELOPE_MIN/AMP_ENVELOPE_MAX, 1.0f/releaseCount);
+ mAttackMult = powf(AMP_ENVELOPE_MAX/AMP_ENVELOPE_MIN, 1.0f/attackCount);
+ mReleaseMult = powf(AMP_ENVELOPE_MIN/AMP_ENVELOPE_MAX, 1.0f/releaseCount);
return AL_TRUE;
}
-static ALvoid ALcompressorState_update(ALcompressorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALcompressorState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
- ALuint i;
- state->mEnabled = props->Compressor.OnOff;
+ mEnabled = props->Compressor.OnOff;
- state->OutBuffer = device->FOAOut.Buffer;
- state->OutChannels = device->FOAOut.NumChannels;
- for(i = 0;i < 4;i++)
- ComputePanGains(&device->FOAOut, aluMatrixf::Identity.m[i], slot->Params.Gain,
- state->mGain[i]);
+ mOutBuffer = device->FOAOut.Buffer;
+ mOutChannels = device->FOAOut.NumChannels;
+ for(ALsizei i{0};i < 4;i++)
+ ComputePanGains(&device->FOAOut, aluMatrixf::Identity.m[i], slot->Params.Gain, mGain[i]);
}
-static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALcompressorState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
ALsizei i, j, k;
ALsizei base;
@@ -110,10 +93,10 @@ static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei Sample
{
ALfloat gains[256];
ALsizei td = mini(256, SamplesToDo-base);
- ALfloat env = state->mEnvFollower;
+ ALfloat env = mEnvFollower;
/* Generate the per-sample gains from the signal envelope. */
- if(state->mEnabled)
+ if(mEnabled)
{
for(i = 0;i < td;++i)
{
@@ -123,9 +106,9 @@ static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei Sample
ALfloat amplitude = clampf(fabsf(SamplesIn[0][base+i]),
AMP_ENVELOPE_MIN, AMP_ENVELOPE_MAX);
if(amplitude > env)
- env = minf(env*state->mAttackMult, amplitude);
+ env = minf(env*mAttackMult, amplitude);
else if(amplitude < env)
- env = maxf(env*state->mReleaseMult, amplitude);
+ env = maxf(env*mReleaseMult, amplitude);
/* Apply the reciprocal of the envelope to normalize the volume
* (compress the dynamic range).
@@ -143,21 +126,21 @@ static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei Sample
{
ALfloat amplitude = 1.0f;
if(amplitude > env)
- env = minf(env*state->mAttackMult, amplitude);
+ env = minf(env*mAttackMult, amplitude);
else if(amplitude < env)
- env = maxf(env*state->mReleaseMult, amplitude);
+ env = maxf(env*mReleaseMult, amplitude);
gains[i] = 1.0f / env;
}
}
- state->mEnvFollower = env;
+ mEnvFollower = env;
/* Now compress the signal amplitude to output. */
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
{
for(k = 0;k < NumChannels;k++)
{
- ALfloat gain = state->mGain[j][k];
+ ALfloat gain = mGain[j][k];
if(!(fabsf(gain) > GAIN_SILENCE_THRESHOLD))
continue;
@@ -172,15 +155,11 @@ static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei Sample
struct CompressorStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *CompressorStateFactory::create()
-{
- ALcompressorState *state;
- NEW_OBJ0(state, ALcompressorState)();
- return state;
-}
+EffectState *CompressorStateFactory::create()
+{ return new ALcompressorState{}; }
EffectStateFactory *CompressorStateFactory_getFactory(void)
{
diff --git a/Alc/effects/dedicated.cpp b/Alc/effects/dedicated.cpp
index 8a59fd4b..491b57ec 100644
--- a/Alc/effects/dedicated.cpp
+++ b/Alc/effects/dedicated.cpp
@@ -31,45 +31,30 @@
#include "alu.h"
-struct ALdedicatedState final : public ALeffectState {
+struct ALdedicatedState final : public EffectState {
ALfloat mCurrentGains[MAX_OUTPUT_CHANNELS];
ALfloat mTargetGains[MAX_OUTPUT_CHANNELS];
-};
-
-static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state);
-static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *device);
-static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALdedicatedState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState);
-static void ALdedicatedState_Construct(ALdedicatedState *state)
-{
- new (state) ALdedicatedState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALdedicatedState, ALeffectState, state);
-}
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALdedicatedState();
-}
+ DEF_NEWDEL(ALdedicatedState)
+};
-static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *UNUSED(device))
+ALboolean ALdedicatedState::deviceUpdate(ALCdevice *UNUSED(device))
{
- std::fill(std::begin(state->mCurrentGains), std::end(state->mCurrentGains), 0.0f);
+ std::fill(std::begin(mCurrentGains), std::end(mCurrentGains), 0.0f);
return AL_TRUE;
}
-static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALdedicatedState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALfloat Gain;
- std::fill(std::begin(state->mTargetGains), std::end(state->mTargetGains), 0.0f);
+ std::fill(std::begin(mTargetGains), std::end(mTargetGains), 0.0f);
Gain = slot->Params.Gain * props->Dedicated.Gain;
if(slot->Params.EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
@@ -77,9 +62,9 @@ static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext
int idx;
if((idx=GetChannelIdxByName(&device->RealOut, LFE)) != -1)
{
- state->OutBuffer = device->RealOut.Buffer;
- state->OutChannels = device->RealOut.NumChannels;
- state->mTargetGains[idx] = Gain;
+ mOutBuffer = device->RealOut.Buffer;
+ mOutChannels = device->RealOut.NumChannels;
+ mTargetGains[idx] = Gain;
}
}
else if(slot->Params.EffectType == AL_EFFECT_DEDICATED_DIALOGUE)
@@ -89,39 +74,35 @@ static ALvoid ALdedicatedState_update(ALdedicatedState *state, const ALCcontext
int idx{GetChannelIdxByName(&device->RealOut, FrontCenter)};
if(idx != -1)
{
- state->OutBuffer = device->RealOut.Buffer;
- state->OutChannels = device->RealOut.NumChannels;
- state->mTargetGains[idx] = Gain;
+ mOutBuffer = device->RealOut.Buffer;
+ mOutChannels = device->RealOut.NumChannels;
+ mTargetGains[idx] = Gain;
}
else
{
ALfloat coeffs[MAX_AMBI_COEFFS];
CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- state->OutBuffer = device->Dry.Buffer;
- state->OutChannels = device->Dry.NumChannels;
- ComputePanGains(&device->Dry, coeffs, Gain, state->mTargetGains);
+ mOutBuffer = device->Dry.Buffer;
+ mOutChannels = device->Dry.NumChannels;
+ ComputePanGains(&device->Dry, coeffs, Gain, mTargetGains);
}
}
}
-static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALdedicatedState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- MixSamples(SamplesIn[0], NumChannels, SamplesOut, state->mCurrentGains,
- state->mTargetGains, SamplesToDo, 0, SamplesToDo);
+ MixSamples(SamplesIn[0], NumChannels, SamplesOut, mCurrentGains,
+ mTargetGains, SamplesToDo, 0, SamplesToDo);
}
struct DedicatedStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *DedicatedStateFactory::create()
-{
- ALdedicatedState *state;
- NEW_OBJ0(state, ALdedicatedState)();
- return state;
-}
+EffectState *DedicatedStateFactory::create()
+{ return new ALdedicatedState{}; }
EffectStateFactory *DedicatedStateFactory_getFactory(void)
{
diff --git a/Alc/effects/distortion.cpp b/Alc/effects/distortion.cpp
index 48acfa56..a2681e3d 100644
--- a/Alc/effects/distortion.cpp
+++ b/Alc/effects/distortion.cpp
@@ -31,7 +31,7 @@
#include "filters/defs.h"
-struct ALdistortionState final : public ALeffectState {
+struct ALdistortionState final : public EffectState {
/* Effect gains for each channel */
ALfloat mGain[MAX_OUTPUT_CHANNELS]{};
@@ -41,39 +41,24 @@ struct ALdistortionState final : public ALeffectState {
ALfloat mAttenuation{};
ALfloat mEdgeCoeff{};
- ALfloat Buffer[2][BUFFERSIZE]{};
-};
-
-static ALvoid ALdistortionState_Destruct(ALdistortionState *state);
-static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device);
-static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALdistortionState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState);
+ ALfloat mBuffer[2][BUFFERSIZE]{};
-static void ALdistortionState_Construct(ALdistortionState *state)
-{
- new (state) ALdistortionState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALdistortionState, ALeffectState, state);
-}
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static ALvoid ALdistortionState_Destruct(ALdistortionState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALdistortionState();
-}
+ DEF_NEWDEL(ALdistortionState)
+};
-static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *UNUSED(device))
+ALboolean ALdistortionState::deviceUpdate(ALCdevice *UNUSED(device))
{
- BiquadFilter_clear(&state->mLowpass);
- BiquadFilter_clear(&state->mBandpass);
+ BiquadFilter_clear(&mLowpass);
+ BiquadFilter_clear(&mBandpass);
return AL_TRUE;
}
-static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALdistortionState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALfloat frequency = (ALfloat)device->Frequency;
@@ -85,7 +70,7 @@ static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontex
/* Store waveshaper edge settings. */
edge = sinf(props->Distortion.Edge * (F_PI_2));
edge = minf(edge, 0.99f);
- state->mEdgeCoeff = 2.0f * edge / (1.0f-edge);
+ mEdgeCoeff = 2.0f * edge / (1.0f-edge);
cutoff = props->Distortion.LowpassCutoff;
/* Bandwidth value is constant in octaves. */
@@ -93,25 +78,25 @@ static ALvoid ALdistortionState_update(ALdistortionState *state, const ALCcontex
/* Multiply sampling frequency by the amount of oversampling done during
* processing.
*/
- BiquadFilter_setParams(&state->mLowpass, BiquadType::LowPass, 1.0f,
+ BiquadFilter_setParams(&mLowpass, BiquadType::LowPass, 1.0f,
cutoff / (frequency*4.0f), calc_rcpQ_from_bandwidth(cutoff / (frequency*4.0f), bandwidth)
);
cutoff = props->Distortion.EQCenter;
/* Convert bandwidth in Hz to octaves. */
bandwidth = props->Distortion.EQBandwidth / (cutoff * 0.67f);
- BiquadFilter_setParams(&state->mBandpass, BiquadType::BandPass, 1.0f,
+ BiquadFilter_setParams(&mBandpass, BiquadType::BandPass, 1.0f,
cutoff / (frequency*4.0f), calc_rcpQ_from_bandwidth(cutoff / (frequency*4.0f), bandwidth)
);
CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain*props->Distortion.Gain, state->mGain);
+ ComputePanGains(&device->Dry, coeffs, slot->Params.Gain*props->Distortion.Gain, mGain);
}
-static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALdistortionState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- ALfloat (*RESTRICT buffer)[BUFFERSIZE] = state->Buffer;
- const ALfloat fc = state->mEdgeCoeff;
+ ALfloat (*RESTRICT buffer)[BUFFERSIZE] = mBuffer;
+ const ALfloat fc = mEdgeCoeff;
ALsizei base;
ALsizei i, k;
@@ -135,7 +120,7 @@ static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei Sample
* (which is fortunately first step of distortion). So combine three
* operations into the one.
*/
- BiquadFilter_process(&state->mLowpass, buffer[1], buffer[0], todo);
+ BiquadFilter_process(&mLowpass, buffer[1], buffer[0], todo);
/* Second step, do distortion using waveshaper function to emulate
* signal processing during tube overdriving. Three steps of
@@ -154,7 +139,7 @@ static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei Sample
}
/* Third step, do bandpass filtering of distorted signal. */
- BiquadFilter_process(&state->mBandpass, buffer[1], buffer[0], todo);
+ BiquadFilter_process(&mBandpass, buffer[1], buffer[0], todo);
todo >>= 2;
for(k = 0;k < NumChannels;k++)
@@ -162,7 +147,7 @@ static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei Sample
/* Fourth step, final, do attenuation and perform decimation,
* storing only one sample out of four.
*/
- ALfloat gain = state->mGain[k];
+ ALfloat gain = mGain[k];
if(!(fabsf(gain) > GAIN_SILENCE_THRESHOLD))
continue;
@@ -176,15 +161,11 @@ static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei Sample
struct DistortionStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *DistortionStateFactory::create()
-{
- ALdistortionState *state;
- NEW_OBJ0(state, ALdistortionState)();
- return state;
-}
+EffectState *DistortionStateFactory::create()
+{ return new ALdistortionState{}; }
EffectStateFactory *DistortionStateFactory_getFactory(void)
{
diff --git a/Alc/effects/echo.cpp b/Alc/effects/echo.cpp
index a72b242c..58728b50 100644
--- a/Alc/effects/echo.cpp
+++ b/Alc/effects/echo.cpp
@@ -35,7 +35,7 @@
#include "vector.h"
-struct ALechoState final : public ALeffectState {
+struct ALechoState final : public EffectState {
al::vector<ALfloat,16> mSampleBuffer;
// The echo is two tap. The delay is the number of samples from before the
@@ -54,31 +54,16 @@ struct ALechoState final : public ALeffectState {
ALfloat mFeedGain{0.0f};
BiquadFilter mFilter;
-};
-
-static ALvoid ALechoState_Destruct(ALechoState *state);
-static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device);
-static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALechoState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALechoState);
-static void ALechoState_Construct(ALechoState *state)
-{
- new (state) ALechoState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALechoState, ALeffectState, state);
-}
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static ALvoid ALechoState_Destruct(ALechoState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALechoState();
-}
+ DEF_NEWDEL(ALechoState)
+};
-static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
+ALboolean ALechoState::deviceUpdate(ALCdevice *Device)
{
ALuint maxlen;
@@ -89,14 +74,14 @@ static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
maxlen = NextPowerOf2(maxlen);
if(maxlen <= 0) return AL_FALSE;
- if(maxlen != state->mSampleBuffer.size())
+ if(maxlen != mSampleBuffer.size())
{
- state->mSampleBuffer.resize(maxlen);
- state->mSampleBuffer.shrink_to_fit();
+ mSampleBuffer.resize(maxlen);
+ mSampleBuffer.shrink_to_fit();
}
- std::fill(state->mSampleBuffer.begin(), state->mSampleBuffer.end(), 0.0f);
- for(auto &e : state->mGains)
+ std::fill(mSampleBuffer.begin(), mSampleBuffer.end(), 0.0f);
+ for(auto &e : mGains)
{
std::fill(std::begin(e.Current), std::end(e.Current), 0.0f);
std::fill(std::begin(e.Target), std::end(e.Target), 0.0f);
@@ -105,16 +90,16 @@ static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
return AL_TRUE;
}
-static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALechoState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALuint frequency = device->Frequency;
ALfloat coeffs[MAX_AMBI_COEFFS];
ALfloat gainhf, lrpan, spread;
- state->mTap[0].delay = maxi(float2int(props->Echo.Delay*frequency + 0.5f), 1);
- state->mTap[1].delay = float2int(props->Echo.LRDelay*frequency + 0.5f);
- state->mTap[1].delay += state->mTap[0].delay;
+ mTap[0].delay = maxi(float2int(props->Echo.Delay*frequency + 0.5f), 1);
+ mTap[1].delay = float2int(props->Echo.LRDelay*frequency + 0.5f);
+ mTap[1].delay += mTap[0].delay;
spread = props->Echo.Spread;
if(spread < 0.0f) lrpan = -1.0f;
@@ -124,35 +109,35 @@ static ALvoid ALechoState_update(ALechoState *state, const ALCcontext *context,
*/
spread = asinf(1.0f - fabsf(spread))*4.0f;
- state->mFeedGain = props->Echo.Feedback;
+ mFeedGain = props->Echo.Feedback;
gainhf = maxf(1.0f - props->Echo.Damping, 0.0625f); /* Limit -24dB */
- BiquadFilter_setParams(&state->mFilter, BiquadType::HighShelf,
+ BiquadFilter_setParams(&mFilter, BiquadType::HighShelf,
gainhf, LOWPASSFREQREF/frequency, calc_rcpQ_from_slope(gainhf, 1.0f)
);
/* First tap panning */
CalcAngleCoeffs(-F_PI_2*lrpan, 0.0f, spread, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->mGains[0].Target);
+ ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, mGains[0].Target);
/* Second tap panning */
CalcAngleCoeffs( F_PI_2*lrpan, 0.0f, spread, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->mGains[1].Target);
+ ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, mGains[1].Target);
}
-static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALechoState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- const ALsizei mask = state->mSampleBuffer.size()-1;
- const ALsizei tap1 = state->mTap[0].delay;
- const ALsizei tap2 = state->mTap[1].delay;
- ALfloat *RESTRICT delaybuf = state->mSampleBuffer.data();
- ALsizei offset = state->mOffset;
+ const ALsizei mask = mSampleBuffer.size()-1;
+ const ALsizei tap1 = mTap[0].delay;
+ const ALsizei tap2 = mTap[1].delay;
+ ALfloat *RESTRICT delaybuf = mSampleBuffer.data();
+ ALsizei offset = mOffset;
ALfloat z1, z2, in, out;
ALsizei base;
ALsizei c, i;
- z1 = state->mFilter.z1;
- z2 = state->mFilter.z2;
+ z1 = mFilter.z1;
+ z2 = mFilter.z2;
for(base = 0;base < SamplesToDo;)
{
alignas(16) ALfloat temps[2][128];
@@ -172,37 +157,33 @@ static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const
* feedback attenuation.
*/
in = temps[1][i];
- out = in*state->mFilter.b0 + z1;
- z1 = in*state->mFilter.b1 - out*state->mFilter.a1 + z2;
- z2 = in*state->mFilter.b2 - out*state->mFilter.a2;
+ out = in*mFilter.b0 + z1;
+ z1 = in*mFilter.b1 - out*mFilter.a1 + z2;
+ z2 = in*mFilter.b2 - out*mFilter.a2;
- delaybuf[offset&mask] += out * state->mFeedGain;
+ delaybuf[offset&mask] += out * mFeedGain;
offset++;
}
for(c = 0;c < 2;c++)
- MixSamples(temps[c], NumChannels, SamplesOut, state->mGains[c].Current,
- state->mGains[c].Target, SamplesToDo-base, base, td);
+ MixSamples(temps[c], NumChannels, SamplesOut, mGains[c].Current,
+ mGains[c].Target, SamplesToDo-base, base, td);
base += td;
}
- state->mFilter.z1 = z1;
- state->mFilter.z2 = z2;
+ mFilter.z1 = z1;
+ mFilter.z2 = z2;
- state->mOffset = offset;
+ mOffset = offset;
}
struct EchoStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *EchoStateFactory::create()
-{
- ALechoState *state;
- NEW_OBJ0(state, ALechoState)();
- return state;
-}
+EffectState *EchoStateFactory::create()
+{ return new ALechoState{}; }
EffectStateFactory *EchoStateFactory_getFactory(void)
{
diff --git a/Alc/effects/equalizer.cpp b/Alc/effects/equalizer.cpp
index 814b43a4..6329ede2 100644
--- a/Alc/effects/equalizer.cpp
+++ b/Alc/effects/equalizer.cpp
@@ -76,7 +76,7 @@
* http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt */
-struct ALequalizerState final : public ALeffectState {
+struct ALequalizerState final : public EffectState {
struct {
/* Effect parameters */
BiquadFilter filter[4];
@@ -87,33 +87,18 @@ struct ALequalizerState final : public ALeffectState {
} mChans[MAX_EFFECT_CHANNELS];
ALfloat mSampleBuffer[MAX_EFFECT_CHANNELS][BUFFERSIZE]{};
-};
-
-static ALvoid ALequalizerState_Destruct(ALequalizerState *state);
-static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device);
-static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALequalizerState)
-
-DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState);
-static void ALequalizerState_Construct(ALequalizerState *state)
-{
- new (state) ALequalizerState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALequalizerState, ALeffectState, state);
-}
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-static ALvoid ALequalizerState_Destruct(ALequalizerState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALequalizerState();
-}
+ DEF_NEWDEL(ALequalizerState)
+};
-static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *UNUSED(device))
+ALboolean ALequalizerState::deviceUpdate(ALCdevice *UNUSED(device))
{
- for(auto &e : state->mChans)
+ for(auto &e : mChans)
{
std::for_each(std::begin(e.filter), std::end(e.filter),
[](BiquadFilter &f) -> void
@@ -124,7 +109,7 @@ static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevic
return AL_TRUE;
}
-static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALequalizerState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALfloat frequency = (ALfloat)device->Frequency;
@@ -137,78 +122,68 @@ static ALvoid ALequalizerState_update(ALequalizerState *state, const ALCcontext
*/
gain = maxf(sqrtf(props->Equalizer.LowGain), 0.0625f); /* Limit -24dB */
f0norm = props->Equalizer.LowCutoff/frequency;
- BiquadFilter_setParams(&state->mChans[0].filter[0], BiquadType::LowShelf,
+ BiquadFilter_setParams(&mChans[0].filter[0], BiquadType::LowShelf,
gain, f0norm, calc_rcpQ_from_slope(gain, 0.75f)
);
gain = maxf(props->Equalizer.Mid1Gain, 0.0625f);
f0norm = props->Equalizer.Mid1Center/frequency;
- BiquadFilter_setParams(&state->mChans[0].filter[1], BiquadType::Peaking,
- gain, f0norm, calc_rcpQ_from_bandwidth(
- f0norm, props->Equalizer.Mid1Width
- )
+ BiquadFilter_setParams(&mChans[0].filter[1], BiquadType::Peaking,
+ gain, f0norm, calc_rcpQ_from_bandwidth(f0norm, props->Equalizer.Mid1Width)
);
gain = maxf(props->Equalizer.Mid2Gain, 0.0625f);
f0norm = props->Equalizer.Mid2Center/frequency;
- BiquadFilter_setParams(&state->mChans[0].filter[2], BiquadType::Peaking,
- gain, f0norm, calc_rcpQ_from_bandwidth(
- f0norm, props->Equalizer.Mid2Width
- )
+ BiquadFilter_setParams(&mChans[0].filter[2], BiquadType::Peaking,
+ gain, f0norm, calc_rcpQ_from_bandwidth(f0norm, props->Equalizer.Mid2Width)
);
gain = maxf(sqrtf(props->Equalizer.HighGain), 0.0625f);
f0norm = props->Equalizer.HighCutoff/frequency;
- BiquadFilter_setParams(&state->mChans[0].filter[3], BiquadType::HighShelf,
+ BiquadFilter_setParams(&mChans[0].filter[3], BiquadType::HighShelf,
gain, f0norm, calc_rcpQ_from_slope(gain, 0.75f)
);
/* Copy the filter coefficients for the other input channels. */
for(i = 1;i < MAX_EFFECT_CHANNELS;i++)
{
- BiquadFilter_copyParams(&state->mChans[i].filter[0], &state->mChans[0].filter[0]);
- BiquadFilter_copyParams(&state->mChans[i].filter[1], &state->mChans[0].filter[1]);
- BiquadFilter_copyParams(&state->mChans[i].filter[2], &state->mChans[0].filter[2]);
- BiquadFilter_copyParams(&state->mChans[i].filter[3], &state->mChans[0].filter[3]);
+ BiquadFilter_copyParams(&mChans[i].filter[0], &mChans[0].filter[0]);
+ BiquadFilter_copyParams(&mChans[i].filter[1], &mChans[0].filter[1]);
+ BiquadFilter_copyParams(&mChans[i].filter[2], &mChans[0].filter[2]);
+ BiquadFilter_copyParams(&mChans[i].filter[3], &mChans[0].filter[3]);
}
- state->OutBuffer = device->FOAOut.Buffer;
- state->OutChannels = device->FOAOut.NumChannels;
+ mOutBuffer = device->FOAOut.Buffer;
+ mOutChannels = device->FOAOut.NumChannels;
for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
ComputePanGains(&device->FOAOut, aluMatrixf::Identity.m[i], slot->Params.Gain,
- state->mChans[i].TargetGains);
+ mChans[i].TargetGains);
}
-static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALequalizerState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- ALfloat (*RESTRICT temps)[BUFFERSIZE] = state->mSampleBuffer;
+ ALfloat (*RESTRICT temps)[BUFFERSIZE] = mSampleBuffer;
ALsizei c;
for(c = 0;c < MAX_EFFECT_CHANNELS;c++)
{
- BiquadFilter_process(&state->mChans[c].filter[0], temps[0], SamplesIn[c], SamplesToDo);
- BiquadFilter_process(&state->mChans[c].filter[1], temps[1], temps[0], SamplesToDo);
- BiquadFilter_process(&state->mChans[c].filter[2], temps[2], temps[1], SamplesToDo);
- BiquadFilter_process(&state->mChans[c].filter[3], temps[3], temps[2], SamplesToDo);
-
- MixSamples(temps[3], NumChannels, SamplesOut,
- state->mChans[c].CurrentGains, state->mChans[c].TargetGains,
- SamplesToDo, 0, SamplesToDo
- );
+ BiquadFilter_process(&mChans[c].filter[0], temps[0], SamplesIn[c], SamplesToDo);
+ BiquadFilter_process(&mChans[c].filter[1], temps[1], temps[0], SamplesToDo);
+ BiquadFilter_process(&mChans[c].filter[2], temps[2], temps[1], SamplesToDo);
+ BiquadFilter_process(&mChans[c].filter[3], temps[3], temps[2], SamplesToDo);
+
+ MixSamples(temps[3], NumChannels, SamplesOut, mChans[c].CurrentGains,
+ mChans[c].TargetGains, SamplesToDo, 0, SamplesToDo);
}
}
struct EqualizerStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *EqualizerStateFactory::create()
-{
- ALequalizerState *state;
- NEW_OBJ0(state, ALequalizerState)();
- return state;
-}
+EffectState *EqualizerStateFactory::create()
+{ return new ALequalizerState{}; }
EffectStateFactory *EqualizerStateFactory_getFactory(void)
{
diff --git a/Alc/effects/fshifter.cpp b/Alc/effects/fshifter.cpp
index b4d073da..38fb5492 100644
--- a/Alc/effects/fshifter.cpp
+++ b/Alc/effects/fshifter.cpp
@@ -60,7 +60,7 @@ std::array<ALdouble,HIL_SIZE> InitHannWindow(void)
alignas(16) const std::array<ALdouble,HIL_SIZE> HannWindow = InitHannWindow();
-struct ALfshifterState final : public ALeffectState {
+struct ALfshifterState final : public EffectState {
/* Effect parameters */
ALsizei mCount{};
ALsizei mPhaseStep{};
@@ -79,152 +79,134 @@ struct ALfshifterState final : public ALeffectState {
/* Effect gains for each output channel */
ALfloat mCurrentGains[MAX_OUTPUT_CHANNELS]{};
ALfloat mTargetGains[MAX_OUTPUT_CHANNELS]{};
-};
-ALvoid ALfshifterState_Destruct(ALfshifterState *state);
-ALboolean ALfshifterState_deviceUpdate(ALfshifterState *state, ALCdevice *device);
-ALvoid ALfshifterState_update(ALfshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALfshifterState)
-DEFINE_ALEFFECTSTATE_VTABLE(ALfshifterState);
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-void ALfshifterState_Construct(ALfshifterState *state)
-{
- new (state) ALfshifterState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALfshifterState, ALeffectState, state);
-}
-
-ALvoid ALfshifterState_Destruct(ALfshifterState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALfshifterState();
-}
+ DEF_NEWDEL(ALfshifterState)
+};
-ALboolean ALfshifterState_deviceUpdate(ALfshifterState *state, ALCdevice *UNUSED(device))
+ALboolean ALfshifterState::deviceUpdate(ALCdevice *UNUSED(device))
{
/* (Re-)initializing parameters and clear the buffers. */
- state->mCount = FIFO_LATENCY;
- state->mPhaseStep = 0;
- state->mPhase = 0;
- state->mLdSign = 1.0;
+ mCount = FIFO_LATENCY;
+ mPhaseStep = 0;
+ mPhase = 0;
+ mLdSign = 1.0;
- std::fill(std::begin(state->mInFIFO), std::end(state->mInFIFO), 0.0f);
- std::fill(std::begin(state->mOutFIFO), std::end(state->mOutFIFO), complex_d{});
- std::fill(std::begin(state->mOutputAccum), std::end(state->mOutputAccum), complex_d{});
- std::fill(std::begin(state->mAnalytic), std::end(state->mAnalytic), complex_d{});
+ std::fill(std::begin(mInFIFO), std::end(mInFIFO), 0.0f);
+ std::fill(std::begin(mOutFIFO), std::end(mOutFIFO), complex_d{});
+ std::fill(std::begin(mOutputAccum), std::end(mOutputAccum), complex_d{});
+ std::fill(std::begin(mAnalytic), std::end(mAnalytic), complex_d{});
- std::fill(std::begin(state->mCurrentGains), std::end(state->mCurrentGains), 0.0f);
- std::fill(std::begin(state->mTargetGains), std::end(state->mTargetGains), 0.0f);
+ std::fill(std::begin(mCurrentGains), std::end(mCurrentGains), 0.0f);
+ std::fill(std::begin(mTargetGains), std::end(mTargetGains), 0.0f);
return AL_TRUE;
}
-ALvoid ALfshifterState_update(ALfshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALfshifterState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device{context->Device};
ALfloat step{props->Fshifter.Frequency / (ALfloat)device->Frequency};
- state->mPhaseStep = fastf2i(minf(step, 0.5f) * FRACTIONONE);
+ mPhaseStep = fastf2i(minf(step, 0.5f) * FRACTIONONE);
switch(props->Fshifter.LeftDirection)
{
case AL_FREQUENCY_SHIFTER_DIRECTION_DOWN:
- state->mLdSign = -1.0;
+ mLdSign = -1.0;
break;
case AL_FREQUENCY_SHIFTER_DIRECTION_UP:
- state->mLdSign = 1.0;
+ mLdSign = 1.0;
break;
case AL_FREQUENCY_SHIFTER_DIRECTION_OFF:
- state->mPhase = 0;
- state->mPhaseStep = 0;
+ mPhase = 0;
+ mPhaseStep = 0;
break;
}
ALfloat coeffs[MAX_AMBI_COEFFS];
CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->mTargetGains);
+ ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, mTargetGains);
}
-ALvoid ALfshifterState_process(ALfshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALfshifterState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
static const complex_d complex_zero{0.0, 0.0};
- ALfloat *RESTRICT BufferOut = state->mBufferOut;
+ ALfloat *RESTRICT BufferOut = mBufferOut;
ALsizei j, k, base;
for(base = 0;base < SamplesToDo;)
{
- ALsizei todo = mini(HIL_SIZE-state->mCount, SamplesToDo-base);
+ ALsizei todo = mini(HIL_SIZE-mCount, SamplesToDo-base);
ASSUME(todo > 0);
/* Fill FIFO buffer with samples data */
- k = state->mCount;
+ k = mCount;
for(j = 0;j < todo;j++,k++)
{
- state->mInFIFO[k] = SamplesIn[0][base+j];
- state->mOutdata[base+j] = state->mOutFIFO[k-FIFO_LATENCY];
+ mInFIFO[k] = SamplesIn[0][base+j];
+ mOutdata[base+j] = mOutFIFO[k-FIFO_LATENCY];
}
- state->mCount += todo;
+ mCount += todo;
base += todo;
/* Check whether FIFO buffer is filled */
- if(state->mCount < HIL_SIZE) continue;
- state->mCount = FIFO_LATENCY;
+ if(mCount < HIL_SIZE) continue;
+ mCount = FIFO_LATENCY;
/* Real signal windowing and store in Analytic buffer */
for(k = 0;k < HIL_SIZE;k++)
{
- state->mAnalytic[k].real(state->mInFIFO[k] * HannWindow[k]);
- state->mAnalytic[k].imag(0.0);
+ mAnalytic[k].real(mInFIFO[k] * HannWindow[k]);
+ mAnalytic[k].imag(0.0);
}
/* Processing signal by Discrete Hilbert Transform (analytical signal). */
- complex_hilbert(state->mAnalytic, HIL_SIZE);
+ complex_hilbert(mAnalytic, HIL_SIZE);
/* Windowing and add to output accumulator */
for(k = 0;k < HIL_SIZE;k++)
- state->mOutputAccum[k] += 2.0/OVERSAMP*HannWindow[k]*state->mAnalytic[k];
+ mOutputAccum[k] += 2.0/OVERSAMP*HannWindow[k]*mAnalytic[k];
/* Shift accumulator, input & output FIFO */
- for(k = 0;k < HIL_STEP;k++) state->mOutFIFO[k] = state->mOutputAccum[k];
- for(j = 0;k < HIL_SIZE;k++,j++) state->mOutputAccum[j] = state->mOutputAccum[k];
- for(;j < HIL_SIZE;j++) state->mOutputAccum[j] = complex_zero;
+ for(k = 0;k < HIL_STEP;k++) mOutFIFO[k] = mOutputAccum[k];
+ for(j = 0;k < HIL_SIZE;k++,j++) mOutputAccum[j] = mOutputAccum[k];
+ for(;j < HIL_SIZE;j++) mOutputAccum[j] = complex_zero;
for(k = 0;k < FIFO_LATENCY;k++)
- state->mInFIFO[k] = state->mInFIFO[k+HIL_STEP];
+ mInFIFO[k] = mInFIFO[k+HIL_STEP];
}
/* Process frequency shifter using the analytic signal obtained. */
for(k = 0;k < SamplesToDo;k++)
{
- double phase = state->mPhase * ((1.0/FRACTIONONE) * 2.0*M_PI);
- BufferOut[k] = (float)(state->mOutdata[k].real()*std::cos(phase) +
- state->mOutdata[k].imag()*std::sin(phase)*state->mLdSign);
+ double phase = mPhase * ((1.0/FRACTIONONE) * 2.0*M_PI);
+ BufferOut[k] = (float)(mOutdata[k].real()*std::cos(phase) +
+ mOutdata[k].imag()*std::sin(phase)*mLdSign);
- state->mPhase += state->mPhaseStep;
- state->mPhase &= FRACTIONMASK;
+ mPhase += mPhaseStep;
+ mPhase &= FRACTIONMASK;
}
/* Now, mix the processed sound data to the output. */
- MixSamples(BufferOut, NumChannels, SamplesOut, state->mCurrentGains, state->mTargetGains,
+ MixSamples(BufferOut, NumChannels, SamplesOut, mCurrentGains, mTargetGains,
maxi(SamplesToDo, 512), 0, SamplesToDo);
}
} // namespace
struct FshifterStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *FshifterStateFactory::create()
-{
- ALfshifterState *state;
- NEW_OBJ0(state, ALfshifterState)();
- return state;
-}
+EffectState *FshifterStateFactory::create()
+{ return new ALfshifterState{}; }
EffectStateFactory *FshifterStateFactory_getFactory(void)
{
diff --git a/Alc/effects/modulator.cpp b/Alc/effects/modulator.cpp
index 0062a779..f714f94f 100644
--- a/Alc/effects/modulator.cpp
+++ b/Alc/effects/modulator.cpp
@@ -37,7 +37,7 @@
#define MAX_UPDATE_SAMPLES 128
-struct ALmodulatorState final : public ALeffectState {
+struct ALmodulatorState final : public EffectState {
void (*mGetSamples)(ALfloat*RESTRICT, ALsizei, const ALsizei, ALsizei){};
ALsizei mIndex{0};
@@ -49,15 +49,14 @@ struct ALmodulatorState final : public ALeffectState {
ALfloat CurrentGains[MAX_OUTPUT_CHANNELS]{};
ALfloat TargetGains[MAX_OUTPUT_CHANNELS]{};
} mChans[MAX_EFFECT_CHANNELS];
-};
-static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state);
-static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *device);
-static ALvoid ALmodulatorState_update(ALmodulatorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALmodulatorState)
-DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState);
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
+
+ DEF_NEWDEL(ALmodulatorState)
+};
#define WAVEFORM_FRACBITS 24
@@ -105,22 +104,9 @@ DECL_TEMPLATE(One)
#undef DECL_TEMPLATE
-static void ALmodulatorState_Construct(ALmodulatorState *state)
-{
- new (state) ALmodulatorState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALmodulatorState, ALeffectState, state);
-}
-
-static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state)
+ALboolean ALmodulatorState::deviceUpdate(ALCdevice *UNUSED(device))
{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALmodulatorState();
-}
-
-static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *UNUSED(device))
-{
- for(auto &e : state->mChans)
+ for(auto &e : mChans)
{
BiquadFilter_clear(&e.Filter);
std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f);
@@ -128,43 +114,42 @@ static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevic
return AL_TRUE;
}
-static ALvoid ALmodulatorState_update(ALmodulatorState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALmodulatorState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALfloat f0norm;
ALsizei i;
- state->mStep = fastf2i(props->Modulator.Frequency / (ALfloat)device->Frequency *
- WAVEFORM_FRACONE);
- state->mStep = clampi(state->mStep, 0, WAVEFORM_FRACONE-1);
+ mStep = fastf2i(props->Modulator.Frequency / (ALfloat)device->Frequency * WAVEFORM_FRACONE);
+ mStep = clampi(mStep, 0, WAVEFORM_FRACONE-1);
- if(state->mStep == 0)
- state->mGetSamples = ModulateOne;
+ if(mStep == 0)
+ mGetSamples = ModulateOne;
else if(props->Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
- state->mGetSamples = ModulateSin;
+ mGetSamples = ModulateSin;
else if(props->Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
- state->mGetSamples = ModulateSaw;
+ mGetSamples = ModulateSaw;
else /*if(Slot->Params.EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SQUARE)*/
- state->mGetSamples = ModulateSquare;
+ mGetSamples = ModulateSquare;
f0norm = props->Modulator.HighPassCutoff / (ALfloat)device->Frequency;
f0norm = clampf(f0norm, 1.0f/512.0f, 0.49f);
/* Bandwidth value is constant in octaves. */
- BiquadFilter_setParams(&state->mChans[0].Filter, BiquadType::HighPass, 1.0f,
+ BiquadFilter_setParams(&mChans[0].Filter, BiquadType::HighPass, 1.0f,
f0norm, calc_rcpQ_from_bandwidth(f0norm, 0.75f));
for(i = 1;i < MAX_EFFECT_CHANNELS;i++)
- BiquadFilter_copyParams(&state->mChans[i].Filter, &state->mChans[0].Filter);
+ BiquadFilter_copyParams(&mChans[i].Filter, &mChans[0].Filter);
- state->OutBuffer = device->FOAOut.Buffer;
- state->OutChannels = device->FOAOut.NumChannels;
+ mOutBuffer = device->FOAOut.Buffer;
+ mOutChannels = device->FOAOut.NumChannels;
for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
ComputePanGains(&device->FOAOut, aluMatrixf::Identity.m[i], slot->Params.Gain,
- state->mChans[i].TargetGains);
+ mChans[i].TargetGains);
}
-static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALmodulatorState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- const ALsizei step = state->mStep;
+ const ALsizei step = mStep;
ALsizei base;
for(base = 0;base < SamplesToDo;)
@@ -173,20 +158,20 @@ static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesT
ALsizei td = mini(MAX_UPDATE_SAMPLES, SamplesToDo-base);
ALsizei c, i;
- state->mGetSamples(modsamples, state->mIndex, step, td);
- state->mIndex += (step*td) & WAVEFORM_FRACMASK;
- state->mIndex &= WAVEFORM_FRACMASK;
+ mGetSamples(modsamples, mIndex, step, td);
+ mIndex += (step*td) & WAVEFORM_FRACMASK;
+ mIndex &= WAVEFORM_FRACMASK;
for(c = 0;c < MAX_EFFECT_CHANNELS;c++)
{
alignas(16) ALfloat temps[MAX_UPDATE_SAMPLES];
- BiquadFilter_process(&state->mChans[c].Filter, temps, &SamplesIn[c][base], td);
+ BiquadFilter_process(&mChans[c].Filter, temps, &SamplesIn[c][base], td);
for(i = 0;i < td;i++)
temps[i] *= modsamples[i];
- MixSamples(temps, NumChannels, SamplesOut, state->mChans[c].CurrentGains,
- state->mChans[c].TargetGains, SamplesToDo-base, base, td);
+ MixSamples(temps, NumChannels, SamplesOut, mChans[c].CurrentGains,
+ mChans[c].TargetGains, SamplesToDo-base, base, td);
}
base += td;
@@ -195,15 +180,11 @@ static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesT
struct ModulatorStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *ModulatorStateFactory::create()
-{
- ALmodulatorState *state;
- NEW_OBJ0(state, ALmodulatorState)();
- return state;
-}
+EffectState *ModulatorStateFactory::create()
+{ return new ALmodulatorState{}; }
EffectStateFactory *ModulatorStateFactory_getFactory(void)
{
diff --git a/Alc/effects/null.cpp b/Alc/effects/null.cpp
index f5641e20..d28a6889 100644
--- a/Alc/effects/null.cpp
+++ b/Alc/effects/null.cpp
@@ -11,47 +11,36 @@
#include "alError.h"
-struct ALnullState final : public ALeffectState {
-};
-
-/* Forward-declare "virtual" functions to define the vtable with. */
-static ALvoid ALnullState_Destruct(ALnullState *state);
-static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device);
-static ALvoid ALnullState_update(ALnullState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALnullState_process(ALnullState *state, ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei mumChannels);
-static void *ALnullState_New(size_t size);
-static void ALnullState_Delete(void *ptr);
+struct ALnullState final : public EffectState {
+ ALnullState();
+ ~ALnullState() override;
-/* Define the ALeffectState vtable for this type. */
-DEFINE_ALEFFECTSTATE_VTABLE(ALnullState);
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
+ DEF_NEWDEL(ALnullState)
+};
/* This constructs the effect state. It's called when the object is first
- * created. Make sure to call the parent Construct function first, and set the
- * vtable!
+ * created.
*/
-static void ALnullState_Construct(ALnullState *state)
+ALnullState::ALnullState()
{
- new (state) ALnullState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALnullState, ALeffectState, state);
}
-/* This destructs (not free!) the effect state. It's called only when the
- * effect slot is no longer used. Make sure to call the parent Destruct
- * function before returning!
+/* This destructs the effect state. It's called only when the effect slot is no
+ * longer used prior to being freed.
*/
-static ALvoid ALnullState_Destruct(ALnullState *state)
+ALnullState::~ALnullState()
{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALnullState();
}
/* This updates the device-dependant effect state. This is called on
* initialization and any time the device parameters (eg. playback frequency,
* format) have been changed.
*/
-static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device))
+ALboolean ALnullState::deviceUpdate(ALCdevice* UNUSED(device))
{
return AL_TRUE;
}
@@ -59,7 +48,7 @@ static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice*
/* This updates the effect state. This is called any time the effect is
* (re)loaded into a slot.
*/
-static ALvoid ALnullState_update(ALnullState* UNUSED(state), const ALCcontext* UNUSED(context), const ALeffectslot* UNUSED(slot), const ALeffectProps* UNUSED(props))
+void ALnullState::update(const ALCcontext* UNUSED(context), const ALeffectslot* UNUSED(slot), const ALeffectProps* UNUSED(props))
{
}
@@ -67,38 +56,18 @@ static ALvoid ALnullState_update(ALnullState* UNUSED(state), const ALCcontext* U
* input to the output buffer. The result should be added to the output buffer,
* not replace it.
*/
-static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALsizei UNUSED(samplesToDo), const ALfloatBUFFERSIZE*RESTRICT UNUSED(samplesIn), ALfloatBUFFERSIZE*RESTRICT UNUSED(samplesOut), ALsizei UNUSED(numChannels))
+void ALnullState::process(ALsizei UNUSED(samplesToDo), const ALfloat (*RESTRICT UNUSED(samplesIn))[BUFFERSIZE], ALfloat (*RESTRICT UNUSED(samplesOut))[BUFFERSIZE], ALsizei UNUSED(numChannels))
{
}
-/* This allocates memory to store the object, before it gets constructed.
- * DECLARE_DEFAULT_ALLOCATORS can be used to declare a default method.
- */
-static void *ALnullState_New(size_t size)
-{
- return al_calloc(16, size);
-}
-
-/* This frees the memory used by the object, after it has been destructed.
- * DECLARE_DEFAULT_ALLOCATORS can be used to declare a default method.
- */
-static void ALnullState_Delete(void *ptr)
-{
- al_free(ptr);
-}
-
struct NullStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
/* Creates ALeffectState objects of the appropriate type. */
-ALeffectState *NullStateFactory::create()
-{
- ALnullState *state;
- NEW_OBJ0(state, ALnullState)();
- return state;
-}
+EffectState *NullStateFactory::create()
+{ return new ALnullState{}; }
EffectStateFactory *NullStateFactory_getFactory(void)
{
diff --git a/Alc/effects/pshifter.cpp b/Alc/effects/pshifter.cpp
index ec473678..3c375499 100644
--- a/Alc/effects/pshifter.cpp
+++ b/Alc/effects/pshifter.cpp
@@ -117,7 +117,7 @@ inline complex_d polar2rect(const ALphasor &number)
{ return std::polar<double>(number.Amplitude, number.Phase); }
-struct ALpshifterState final : public ALeffectState {
+struct ALpshifterState final : public EffectState {
/* Effect parameters */
ALsizei mCount;
ALsizei mPitchShiftI;
@@ -141,53 +141,39 @@ struct ALpshifterState final : public ALeffectState {
/* Effect gains for each output channel */
ALfloat mCurrentGains[MAX_OUTPUT_CHANNELS];
ALfloat mTargetGains[MAX_OUTPUT_CHANNELS];
-};
-static ALvoid ALpshifterState_Destruct(ALpshifterState *state);
-static ALboolean ALpshifterState_deviceUpdate(ALpshifterState *state, ALCdevice *device);
-static ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props);
-static ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ALpshifterState)
-DEFINE_ALEFFECTSTATE_VTABLE(ALpshifterState);
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
-void ALpshifterState_Construct(ALpshifterState *state)
-{
- new (state) ALpshifterState{};
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ALpshifterState, ALeffectState, state);
-}
-
-ALvoid ALpshifterState_Destruct(ALpshifterState *state)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
- state->~ALpshifterState();
-}
+ DEF_NEWDEL(ALpshifterState)
+};
-ALboolean ALpshifterState_deviceUpdate(ALpshifterState *state, ALCdevice *device)
+ALboolean ALpshifterState::deviceUpdate(ALCdevice *device)
{
/* (Re-)initializing parameters and clear the buffers. */
- state->mCount = FIFO_LATENCY;
- state->mPitchShiftI = FRACTIONONE;
- state->mPitchShift = 1.0f;
- state->mFreqPerBin = device->Frequency / (ALfloat)STFT_SIZE;
-
- std::fill(std::begin(state->mInFIFO), std::end(state->mInFIFO), 0.0f);
- std::fill(std::begin(state->mOutFIFO), std::end(state->mOutFIFO), 0.0f);
- std::fill(std::begin(state->mLastPhase), std::end(state->mLastPhase), 0.0);
- std::fill(std::begin(state->mSumPhase), std::end(state->mSumPhase), 0.0);
- std::fill(std::begin(state->mOutputAccum), std::end(state->mOutputAccum), 0.0);
- std::fill(std::begin(state->mFFTbuffer), std::end(state->mFFTbuffer), complex_d{});
- std::fill(std::begin(state->mAnalysis_buffer), std::end(state->mAnalysis_buffer), ALfrequencyDomain{});
- std::fill(std::begin(state->mSyntesis_buffer), std::end(state->mSyntesis_buffer), ALfrequencyDomain{});
-
- std::fill(std::begin(state->mCurrentGains), std::end(state->mCurrentGains), 0.0f);
- std::fill(std::begin(state->mTargetGains), std::end(state->mTargetGains), 0.0f);
+ mCount = FIFO_LATENCY;
+ mPitchShiftI = FRACTIONONE;
+ mPitchShift = 1.0f;
+ mFreqPerBin = device->Frequency / (ALfloat)STFT_SIZE;
+
+ std::fill(std::begin(mInFIFO), std::end(mInFIFO), 0.0f);
+ std::fill(std::begin(mOutFIFO), std::end(mOutFIFO), 0.0f);
+ std::fill(std::begin(mLastPhase), std::end(mLastPhase), 0.0);
+ std::fill(std::begin(mSumPhase), std::end(mSumPhase), 0.0);
+ std::fill(std::begin(mOutputAccum), std::end(mOutputAccum), 0.0);
+ std::fill(std::begin(mFFTbuffer), std::end(mFFTbuffer), complex_d{});
+ std::fill(std::begin(mAnalysis_buffer), std::end(mAnalysis_buffer), ALfrequencyDomain{});
+ std::fill(std::begin(mSyntesis_buffer), std::end(mSyntesis_buffer), ALfrequencyDomain{});
+
+ std::fill(std::begin(mCurrentGains), std::end(mCurrentGains), 0.0f);
+ std::fill(std::begin(mTargetGains), std::end(mTargetGains), 0.0f);
return AL_TRUE;
}
-ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
+void ALpshifterState::update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props)
{
const ALCdevice *device = context->Device;
ALfloat coeffs[MAX_AMBI_COEFFS];
@@ -196,30 +182,30 @@ ALvoid ALpshifterState_update(ALpshifterState *state, const ALCcontext *context,
pitch = std::pow(2.0f,
(ALfloat)(props->Pshifter.CoarseTune*100 + props->Pshifter.FineTune) / 1200.0f
);
- state->mPitchShiftI = fastf2i(pitch*FRACTIONONE);
- state->mPitchShift = state->mPitchShiftI * (1.0f/FRACTIONONE);
+ mPitchShiftI = fastf2i(pitch*FRACTIONONE);
+ mPitchShift = mPitchShiftI * (1.0f/FRACTIONONE);
CalcAngleCoeffs(0.0f, 0.0f, 0.0f, coeffs);
- ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, state->mTargetGains);
+ ComputePanGains(&device->Dry, coeffs, slot->Params.Gain, mTargetGains);
}
-ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ALpshifterState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
/* Pitch shifter engine based on the work of Stephan Bernsee.
* http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
*/
static constexpr ALdouble expected{M_PI*2.0 / OVERSAMP};
- const ALdouble freq_per_bin{state->mFreqPerBin};
- ALfloat *RESTRICT bufferOut{state->mBufferOut};
- ALsizei count{state->mCount};
+ const ALdouble freq_per_bin{mFreqPerBin};
+ ALfloat *RESTRICT bufferOut{mBufferOut};
+ ALsizei count{mCount};
for(ALsizei i{0};i < SamplesToDo;)
{
do {
/* Fill FIFO buffer with samples data */
- state->mInFIFO[count] = SamplesIn[0][i];
- bufferOut[i] = state->mOutFIFO[count - FIFO_LATENCY];
+ mInFIFO[count] = SamplesIn[0][i];
+ bufferOut[i] = mOutFIFO[count - FIFO_LATENCY];
count++;
} while(++i < SamplesToDo && count < STFT_SIZE);
@@ -231,13 +217,13 @@ ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, cons
/* Real signal windowing and store in FFTbuffer */
for(ALsizei k{0};k < STFT_SIZE;k++)
{
- state->mFFTbuffer[k].real(state->mInFIFO[k] * HannWindow[k]);
- state->mFFTbuffer[k].imag(0.0);
+ mFFTbuffer[k].real(mInFIFO[k] * HannWindow[k]);
+ mFFTbuffer[k].imag(0.0);
}
/* ANALYSIS */
/* Apply FFT to FFTbuffer data */
- complex_fft(state->mFFTbuffer, STFT_SIZE, -1.0);
+ complex_fft(mFFTbuffer, STFT_SIZE, -1.0);
/* Analyze the obtained data. Since the real FFT is symmetric, only
* STFT_HALF_SIZE+1 samples are needed.
@@ -245,10 +231,10 @@ ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, cons
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
{
/* Compute amplitude and phase */
- ALphasor component{rect2polar(state->mFFTbuffer[k])};
+ ALphasor component{rect2polar(mFFTbuffer[k])};
/* Compute phase difference and subtract expected phase difference */
- double tmp{(component.Phase - state->mLastPhase[k]) - k*expected};
+ double tmp{(component.Phase - mLastPhase[k]) - k*expected};
/* Map delta phase into +/- Pi interval */
int qpd{double2int(tmp / M_PI)};
@@ -261,29 +247,28 @@ ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, cons
* for maintain the gain (because half of bins are used) and store
* amplitude and true frequency in analysis buffer.
*/
- state->mAnalysis_buffer[k].Amplitude = 2.0 * component.Amplitude;
- state->mAnalysis_buffer[k].Frequency = (k + tmp) * freq_per_bin;
+ mAnalysis_buffer[k].Amplitude = 2.0 * component.Amplitude;
+ mAnalysis_buffer[k].Frequency = (k + tmp) * freq_per_bin;
/* Store actual phase[k] for the calculations in the next frame*/
- state->mLastPhase[k] = component.Phase;
+ mLastPhase[k] = component.Phase;
}
/* PROCESSING */
/* pitch shifting */
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
{
- state->mSyntesis_buffer[k].Amplitude = 0.0;
- state->mSyntesis_buffer[k].Frequency = 0.0;
+ mSyntesis_buffer[k].Amplitude = 0.0;
+ mSyntesis_buffer[k].Frequency = 0.0;
}
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
{
- ALsizei j{(k*state->mPitchShiftI) >> FRACTIONBITS};
+ ALsizei j{(k*mPitchShiftI) >> FRACTIONBITS};
if(j >= STFT_HALF_SIZE+1) break;
- state->mSyntesis_buffer[j].Amplitude += state->mAnalysis_buffer[k].Amplitude;
- state->mSyntesis_buffer[j].Frequency = state->mAnalysis_buffer[k].Frequency *
- state->mPitchShift;
+ mSyntesis_buffer[j].Amplitude += mAnalysis_buffer[k].Amplitude;
+ mSyntesis_buffer[j].Frequency = mAnalysis_buffer[k].Frequency * mPitchShift;
}
/* SYNTHESIS */
@@ -294,56 +279,52 @@ ALvoid ALpshifterState_process(ALpshifterState *state, ALsizei SamplesToDo, cons
ALdouble tmp;
/* Compute bin deviation from scaled freq */
- tmp = state->mSyntesis_buffer[k].Frequency/freq_per_bin - k;
+ tmp = mSyntesis_buffer[k].Frequency/freq_per_bin - k;
/* Calculate actual delta phase and accumulate it to get bin phase */
- state->mSumPhase[k] += (k + tmp) * expected;
+ mSumPhase[k] += (k + tmp) * expected;
- component.Amplitude = state->mSyntesis_buffer[k].Amplitude;
- component.Phase = state->mSumPhase[k];
+ component.Amplitude = mSyntesis_buffer[k].Amplitude;
+ component.Phase = mSumPhase[k];
/* Compute phasor component to cartesian complex number and storage it into FFTbuffer*/
- state->mFFTbuffer[k] = polar2rect(component);
+ mFFTbuffer[k] = polar2rect(component);
}
/* zero negative frequencies for recontruct a real signal */
for(ALsizei k{STFT_HALF_SIZE+1};k < STFT_SIZE;k++)
- state->mFFTbuffer[k] = complex_d{};
+ mFFTbuffer[k] = complex_d{};
/* Apply iFFT to buffer data */
- complex_fft(state->mFFTbuffer, STFT_SIZE, 1.0);
+ complex_fft(mFFTbuffer, STFT_SIZE, 1.0);
/* Windowing and add to output */
for(ALsizei k{0};k < STFT_SIZE;k++)
- state->mOutputAccum[k] += HannWindow[k] * state->mFFTbuffer[k].real() /
- (0.5 * STFT_HALF_SIZE * OVERSAMP);
+ mOutputAccum[k] += HannWindow[k] * mFFTbuffer[k].real() /
+ (0.5 * STFT_HALF_SIZE * OVERSAMP);
/* Shift accumulator, input & output FIFO */
ALsizei j, k;
- for(k = 0;k < STFT_STEP;k++) state->mOutFIFO[k] = (ALfloat)state->mOutputAccum[k];
- for(j = 0;k < STFT_SIZE;k++,j++) state->mOutputAccum[j] = state->mOutputAccum[k];
- for(;j < STFT_SIZE;j++) state->mOutputAccum[j] = 0.0;
+ for(k = 0;k < STFT_STEP;k++) mOutFIFO[k] = (ALfloat)mOutputAccum[k];
+ for(j = 0;k < STFT_SIZE;k++,j++) mOutputAccum[j] = mOutputAccum[k];
+ for(;j < STFT_SIZE;j++) mOutputAccum[j] = 0.0;
for(k = 0;k < FIFO_LATENCY;k++)
- state->mInFIFO[k] = state->mInFIFO[k+STFT_STEP];
+ mInFIFO[k] = mInFIFO[k+STFT_STEP];
}
- state->mCount = count;
+ mCount = count;
/* Now, mix the processed sound data to the output. */
- MixSamples(bufferOut, NumChannels, SamplesOut, state->mCurrentGains, state->mTargetGains,
+ MixSamples(bufferOut, NumChannels, SamplesOut, mCurrentGains, mTargetGains,
maxi(SamplesToDo, 512), 0, SamplesToDo);
}
} // namespace
struct PshifterStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *PshifterStateFactory::create()
-{
- ALpshifterState *state;
- NEW_OBJ0(state, ALpshifterState)();
- return state;
-}
+EffectState *PshifterStateFactory::create()
+{ return new ALpshifterState{}; }
EffectStateFactory *PshifterStateFactory_getFactory(void)
{
diff --git a/Alc/effects/reverb.cpp b/Alc/effects/reverb.cpp
index 229cd316..91d2d0d6 100644
--- a/Alc/effects/reverb.cpp
+++ b/Alc/effects/reverb.cpp
@@ -280,7 +280,7 @@ typedef struct LateReverb {
ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS];
} LateReverb;
-struct ReverbState final : public ALeffectState {
+struct ReverbState final : public EffectState {
/* All delay lines are allocated as a single buffer to reduce memory
* fragmentation and management code.
*/
@@ -332,116 +332,106 @@ struct ReverbState final : public ALeffectState {
/* Temporary storage used when processing. */
alignas(16) ALfloat mTempSamples[NUM_LINES][MAX_UPDATE_SAMPLES];
alignas(16) ALfloat mMixBuffer[NUM_LINES][MAX_UPDATE_SAMPLES];
-};
-static ALvoid ReverbState_Destruct(ReverbState *State);
-static ALboolean ReverbState_deviceUpdate(ReverbState *State, ALCdevice *Device);
-static ALvoid ReverbState_update(ReverbState *State, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props);
-static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels);
-DECLARE_DEFAULT_ALLOCATORS(ReverbState)
-DEFINE_ALEFFECTSTATE_VTABLE(ReverbState);
+ ReverbState();
-static void ReverbState_Construct(ReverbState *state)
-{
- new (state) ReverbState{};
+ ALboolean deviceUpdate(ALCdevice *device) override;
+ void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) override;
+ void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) override;
- ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
- SET_VTABLE2(ReverbState, ALeffectState, state);
+ DEF_NEWDEL(ReverbState)
+};
- state->mParams.Density = AL_EAXREVERB_DEFAULT_DENSITY;
- state->mParams.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
- state->mParams.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME;
- state->mParams.HFDecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME*AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
- state->mParams.LFDecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME*AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
- state->mParams.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
- state->mParams.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
+ReverbState::ReverbState()
+{
+ mParams.Density = AL_EAXREVERB_DEFAULT_DENSITY;
+ mParams.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
+ mParams.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME;
+ mParams.HFDecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME*AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
+ mParams.LFDecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME*AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
+ mParams.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
+ mParams.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
for(ALsizei i{0};i < NUM_LINES;i++)
{
- BiquadFilter_clear(&state->mFilter[i].Lp);
- BiquadFilter_clear(&state->mFilter[i].Hp);
+ BiquadFilter_clear(&mFilter[i].Lp);
+ BiquadFilter_clear(&mFilter[i].Hp);
}
- state->mDelay.Mask = 0;
- state->mDelay.Line = NULL;
+ mDelay.Mask = 0;
+ mDelay.Line = NULL;
for(ALsizei i{0};i < NUM_LINES;i++)
{
- state->mEarlyDelayTap[i][0] = 0;
- state->mEarlyDelayTap[i][1] = 0;
- state->mEarlyDelayCoeff[i][0] = 0.0f;
- state->mEarlyDelayCoeff[i][1] = 0.0f;
+ mEarlyDelayTap[i][0] = 0;
+ mEarlyDelayTap[i][1] = 0;
+ mEarlyDelayCoeff[i][0] = 0.0f;
+ mEarlyDelayCoeff[i][1] = 0.0f;
}
- state->mLateFeedTap = 0;
+ mLateFeedTap = 0;
for(ALsizei i{0};i < NUM_LINES;i++)
{
- state->mLateDelayTap[i][0] = 0;
- state->mLateDelayTap[i][1] = 0;
+ mLateDelayTap[i][0] = 0;
+ mLateDelayTap[i][1] = 0;
}
- state->mMixX = 0.0f;
- state->mMixY = 0.0f;
+ mMixX = 0.0f;
+ mMixY = 0.0f;
- state->mEarly.VecAp.Delay.Mask = 0;
- state->mEarly.VecAp.Delay.Line = NULL;
- state->mEarly.VecAp.Coeff = 0.0f;
- state->mEarly.Delay.Mask = 0;
- state->mEarly.Delay.Line = NULL;
+ mEarly.VecAp.Delay.Mask = 0;
+ mEarly.VecAp.Delay.Line = NULL;
+ mEarly.VecAp.Coeff = 0.0f;
+ mEarly.Delay.Mask = 0;
+ mEarly.Delay.Line = NULL;
for(ALsizei i{0};i < NUM_LINES;i++)
{
- state->mEarly.VecAp.Offset[i][0] = 0;
- state->mEarly.VecAp.Offset[i][1] = 0;
- state->mEarly.Offset[i][0] = 0;
- state->mEarly.Offset[i][1] = 0;
- state->mEarly.Coeff[i][0] = 0.0f;
- state->mEarly.Coeff[i][1] = 0.0f;
+ mEarly.VecAp.Offset[i][0] = 0;
+ mEarly.VecAp.Offset[i][1] = 0;
+ mEarly.Offset[i][0] = 0;
+ mEarly.Offset[i][1] = 0;
+ mEarly.Coeff[i][0] = 0.0f;
+ mEarly.Coeff[i][1] = 0.0f;
}
- state->mLate.DensityGain[0] = 0.0f;
- state->mLate.DensityGain[1] = 0.0f;
- state->mLate.Delay.Mask = 0;
- state->mLate.Delay.Line = NULL;
- state->mLate.VecAp.Delay.Mask = 0;
- state->mLate.VecAp.Delay.Line = NULL;
- state->mLate.VecAp.Coeff = 0.0f;
+ mLate.DensityGain[0] = 0.0f;
+ mLate.DensityGain[1] = 0.0f;
+ mLate.Delay.Mask = 0;
+ mLate.Delay.Line = NULL;
+ mLate.VecAp.Delay.Mask = 0;
+ mLate.VecAp.Delay.Line = NULL;
+ mLate.VecAp.Coeff = 0.0f;
for(ALsizei i{0};i < NUM_LINES;i++)
{
- state->mLate.Offset[i][0] = 0;
- state->mLate.Offset[i][1] = 0;
+ mLate.Offset[i][0] = 0;
+ mLate.Offset[i][1] = 0;
- state->mLate.VecAp.Offset[i][0] = 0;
- state->mLate.VecAp.Offset[i][1] = 0;
+ mLate.VecAp.Offset[i][0] = 0;
+ mLate.VecAp.Offset[i][1] = 0;
- state->mLate.T60[i].MidGain[0] = 0.0f;
- state->mLate.T60[i].MidGain[1] = 0.0f;
- BiquadFilter_clear(&state->mLate.T60[i].HFFilter);
- BiquadFilter_clear(&state->mLate.T60[i].LFFilter);
+ mLate.T60[i].MidGain[0] = 0.0f;
+ mLate.T60[i].MidGain[1] = 0.0f;
+ BiquadFilter_clear(&mLate.T60[i].HFFilter);
+ BiquadFilter_clear(&mLate.T60[i].LFFilter);
}
for(ALsizei i{0};i < NUM_LINES;i++)
{
for(ALsizei j{0};j < MAX_OUTPUT_CHANNELS;j++)
{
- state->mEarly.CurrentGain[i][j] = 0.0f;
- state->mEarly.PanGain[i][j] = 0.0f;
- state->mLate.CurrentGain[i][j] = 0.0f;
- state->mLate.PanGain[i][j] = 0.0f;
+ mEarly.CurrentGain[i][j] = 0.0f;
+ mEarly.PanGain[i][j] = 0.0f;
+ mLate.CurrentGain[i][j] = 0.0f;
+ mLate.PanGain[i][j] = 0.0f;
}
}
- state->mFadeCount = 0;
- state->mMaxUpdate[0] = MAX_UPDATE_SAMPLES;
- state->mMaxUpdate[1] = MAX_UPDATE_SAMPLES;
- state->mOffset = 0;
-}
-
-static ALvoid ReverbState_Destruct(ReverbState *State)
-{
- ALeffectState_Destruct(STATIC_CAST(ALeffectState,State));
- State->~ReverbState();
+ mFadeCount = 0;
+ mMaxUpdate[0] = MAX_UPDATE_SAMPLES;
+ mMaxUpdate[1] = MAX_UPDATE_SAMPLES;
+ mOffset = 0;
}
/**************************************
@@ -555,70 +545,70 @@ static ALboolean AllocLines(const ALuint frequency, ReverbState *State)
return AL_TRUE;
}
-static ALboolean ReverbState_deviceUpdate(ReverbState *State, ALCdevice *Device)
+ALboolean ReverbState::deviceUpdate(ALCdevice *Device)
{
ALuint frequency = Device->Frequency;
ALfloat multiplier;
ALsizei i, j;
/* Allocate the delay lines. */
- if(!AllocLines(frequency, State))
+ if(!AllocLines(frequency, this))
return AL_FALSE;
multiplier = CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY);
/* The late feed taps are set a fixed position past the latest delay tap. */
- State->mLateFeedTap = float2int((AL_EAXREVERB_MAX_REFLECTIONS_DELAY +
- EARLY_TAP_LENGTHS[NUM_LINES-1]*multiplier) *
- frequency);
+ mLateFeedTap = float2int((AL_EAXREVERB_MAX_REFLECTIONS_DELAY +
+ EARLY_TAP_LENGTHS[NUM_LINES-1]*multiplier) *
+ frequency);
/* Clear filters and gain coefficients since the delay lines were all just
* cleared (if not reallocated).
*/
for(i = 0;i < NUM_LINES;i++)
{
- BiquadFilter_clear(&State->mFilter[i].Lp);
- BiquadFilter_clear(&State->mFilter[i].Hp);
+ BiquadFilter_clear(&mFilter[i].Lp);
+ BiquadFilter_clear(&mFilter[i].Hp);
}
for(i = 0;i < NUM_LINES;i++)
{
- State->mEarlyDelayCoeff[i][0] = 0.0f;
- State->mEarlyDelayCoeff[i][1] = 0.0f;
+ mEarlyDelayCoeff[i][0] = 0.0f;
+ mEarlyDelayCoeff[i][1] = 0.0f;
}
for(i = 0;i < NUM_LINES;i++)
{
- State->mEarly.Coeff[i][0] = 0.0f;
- State->mEarly.Coeff[i][1] = 0.0f;
+ mEarly.Coeff[i][0] = 0.0f;
+ mEarly.Coeff[i][1] = 0.0f;
}
- State->mLate.DensityGain[0] = 0.0f;
- State->mLate.DensityGain[1] = 0.0f;
+ mLate.DensityGain[0] = 0.0f;
+ mLate.DensityGain[1] = 0.0f;
for(i = 0;i < NUM_LINES;i++)
{
- State->mLate.T60[i].MidGain[0] = 0.0f;
- State->mLate.T60[i].MidGain[1] = 0.0f;
- BiquadFilter_clear(&State->mLate.T60[i].HFFilter);
- BiquadFilter_clear(&State->mLate.T60[i].LFFilter);
+ mLate.T60[i].MidGain[0] = 0.0f;
+ mLate.T60[i].MidGain[1] = 0.0f;
+ BiquadFilter_clear(&mLate.T60[i].HFFilter);
+ BiquadFilter_clear(&mLate.T60[i].LFFilter);
}
for(i = 0;i < NUM_LINES;i++)
{
for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
{
- State->mEarly.CurrentGain[i][j] = 0.0f;
- State->mEarly.PanGain[i][j] = 0.0f;
- State->mLate.CurrentGain[i][j] = 0.0f;
- State->mLate.PanGain[i][j] = 0.0f;
+ mEarly.CurrentGain[i][j] = 0.0f;
+ mEarly.PanGain[i][j] = 0.0f;
+ mLate.CurrentGain[i][j] = 0.0f;
+ mLate.PanGain[i][j] = 0.0f;
}
}
/* Reset counters and offset base. */
- State->mFadeCount = 0;
- State->mMaxUpdate[0] = MAX_UPDATE_SAMPLES;
- State->mMaxUpdate[1] = MAX_UPDATE_SAMPLES;
- State->mOffset = 0;
+ mFadeCount = 0;
+ mMaxUpdate[0] = MAX_UPDATE_SAMPLES;
+ mMaxUpdate[1] = MAX_UPDATE_SAMPLES;
+ mOffset = 0;
return AL_TRUE;
}
@@ -902,8 +892,8 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection
aluMatrixf transform, rot;
ALsizei i;
- STATIC_CAST(ALeffectState,State)->OutBuffer = Device->FOAOut.Buffer;
- STATIC_CAST(ALeffectState,State)->OutChannels = Device->FOAOut.NumChannels;
+ State->mOutBuffer = Device->FOAOut.Buffer;
+ State->mOutChannels = Device->FOAOut.NumChannels;
/* Note: _res is transposed. */
#define MATRIX_MULT(_res, _m1, _m2) do { \
@@ -934,7 +924,7 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection
#undef MATRIX_MULT
}
-static void ReverbState_update(ReverbState *State, const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props)
+void ReverbState::update(const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props)
{
const ALCdevice *Device = Context->Device;
const ALlistener &Listener = Context->Listener;
@@ -950,29 +940,29 @@ static void ReverbState_update(ReverbState *State, const ALCcontext *Context, co
* killing most of the signal.
*/
gainhf = maxf(props->Reverb.GainHF, 0.001f);
- BiquadFilter_setParams(&State->mFilter[0].Lp, BiquadType::HighShelf, gainhf, hf0norm,
+ BiquadFilter_setParams(&mFilter[0].Lp, BiquadType::HighShelf, gainhf, hf0norm,
calc_rcpQ_from_slope(gainhf, 1.0f));
lf0norm = minf(props->Reverb.LFReference / frequency, 0.49f);
gainlf = maxf(props->Reverb.GainLF, 0.001f);
- BiquadFilter_setParams(&State->mFilter[0].Hp, BiquadType::LowShelf, gainlf, lf0norm,
+ BiquadFilter_setParams(&mFilter[0].Hp, BiquadType::LowShelf, gainlf, lf0norm,
calc_rcpQ_from_slope(gainlf, 1.0f));
for(i = 1;i < NUM_LINES;i++)
{
- BiquadFilter_copyParams(&State->mFilter[i].Lp, &State->mFilter[0].Lp);
- BiquadFilter_copyParams(&State->mFilter[i].Hp, &State->mFilter[0].Hp);
+ BiquadFilter_copyParams(&mFilter[i].Lp, &mFilter[0].Lp);
+ BiquadFilter_copyParams(&mFilter[i].Hp, &mFilter[0].Hp);
}
/* Update the main effect delay and associated taps. */
UpdateDelayLine(props->Reverb.ReflectionsDelay, props->Reverb.LateReverbDelay,
props->Reverb.Density, props->Reverb.DecayTime, frequency,
- State);
+ this);
/* Update the early lines. */
UpdateEarlyLines(props->Reverb.Density, props->Reverb.Diffusion,
- props->Reverb.DecayTime, frequency, &State->mEarly);
+ props->Reverb.DecayTime, frequency, &mEarly);
/* Get the mixing matrix coefficients. */
- CalcMatrixCoeffs(props->Reverb.Diffusion, &State->mMixX, &State->mMixY);
+ CalcMatrixCoeffs(props->Reverb.Diffusion, &mMixX, &mMixY);
/* If the HF limit parameter is flagged, calculate an appropriate limit
* based on the air absorption parameter.
@@ -992,45 +982,43 @@ static void ReverbState_update(ReverbState *State, const ALCcontext *Context, co
/* Update the late lines. */
UpdateLateLines(props->Reverb.Density, props->Reverb.Diffusion,
lfDecayTime, props->Reverb.DecayTime, hfDecayTime, lf0norm, hf0norm,
- frequency, &State->mLate
+ frequency, &mLate
);
/* Update early and late 3D panning. */
gain = props->Reverb.Gain * Slot->Params.Gain * ReverbBoost;
Update3DPanning(Device, props->Reverb.ReflectionsPan, props->Reverb.LateReverbPan,
props->Reverb.ReflectionsGain*gain, props->Reverb.LateReverbGain*gain,
- State);
+ this);
/* Calculate the max update size from the smallest relevant delay. */
- State->mMaxUpdate[1] = mini(MAX_UPDATE_SAMPLES,
- mini(State->mEarly.Offset[0][1], State->mLate.Offset[0][1])
- );
+ mMaxUpdate[1] = mini(MAX_UPDATE_SAMPLES, mini(mEarly.Offset[0][1], mLate.Offset[0][1]));
/* Determine if delay-line cross-fading is required. Density is essentially
* a master control for the feedback delays, so changes the offsets of many
* delay lines.
*/
- if(State->mParams.Density != props->Reverb.Density ||
+ if(mParams.Density != props->Reverb.Density ||
/* Diffusion and decay times influences the decay rate (gain) of the
* late reverb T60 filter.
*/
- State->mParams.Diffusion != props->Reverb.Diffusion ||
- State->mParams.DecayTime != props->Reverb.DecayTime ||
- State->mParams.HFDecayTime != hfDecayTime ||
- State->mParams.LFDecayTime != lfDecayTime ||
+ mParams.Diffusion != props->Reverb.Diffusion ||
+ mParams.DecayTime != props->Reverb.DecayTime ||
+ mParams.HFDecayTime != hfDecayTime ||
+ mParams.LFDecayTime != lfDecayTime ||
/* HF/LF References control the weighting used to calculate the density
* gain.
*/
- State->mParams.HFReference != props->Reverb.HFReference ||
- State->mParams.LFReference != props->Reverb.LFReference)
- State->mFadeCount = 0;
- State->mParams.Density = props->Reverb.Density;
- State->mParams.Diffusion = props->Reverb.Diffusion;
- State->mParams.DecayTime = props->Reverb.DecayTime;
- State->mParams.HFDecayTime = hfDecayTime;
- State->mParams.LFDecayTime = lfDecayTime;
- State->mParams.HFReference = props->Reverb.HFReference;
- State->mParams.LFReference = props->Reverb.LFReference;
+ mParams.HFReference != props->Reverb.HFReference ||
+ mParams.LFReference != props->Reverb.LFReference)
+ mFadeCount = 0;
+ mParams.Density = props->Reverb.Density;
+ mParams.Diffusion = props->Reverb.Diffusion;
+ mParams.DecayTime = props->Reverb.DecayTime;
+ mParams.HFDecayTime = hfDecayTime;
+ mParams.LFDecayTime = lfDecayTime;
+ mParams.HFReference = props->Reverb.HFReference;
+ mParams.LFReference = props->Reverb.LFReference;
}
@@ -1454,12 +1442,12 @@ static void LateReverb_Faded(ReverbState *State, ALsizei offset, const ALsizei t
VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, temps, todo);
}
-static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
+void ReverbState::process(ALsizei SamplesToDo, const ALfloat (*RESTRICT SamplesIn)[BUFFERSIZE], ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE], ALsizei NumChannels)
{
- ALfloat (*RESTRICT afmt)[MAX_UPDATE_SAMPLES] = State->mTempSamples;
- ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES] = State->mMixBuffer;
- ALsizei fadeCount = State->mFadeCount;
- ALsizei offset = State->mOffset;
+ ALfloat (*RESTRICT afmt)[MAX_UPDATE_SAMPLES] = mTempSamples;
+ ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES] = mMixBuffer;
+ ALsizei fadeCount = mFadeCount;
+ ALsizei offset = mOffset;
ALsizei base, c;
/* Process reverb for these samples. */
@@ -1470,9 +1458,9 @@ static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const
if(FADE_SAMPLES-fadeCount > 0)
{
todo = mini(todo, FADE_SAMPLES-fadeCount);
- todo = mini(todo, State->mMaxUpdate[0]);
+ todo = mini(todo, mMaxUpdate[0]);
}
- todo = mini(todo, State->mMaxUpdate[1]);
+ todo = mini(todo, mMaxUpdate[1]);
/* If this is not the final update, ensure the update size is a
* multiple of 4 for the SIMD mixers.
*/
@@ -1490,11 +1478,11 @@ static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const
for(c = 0;c < NUM_LINES;c++)
{
/* Band-pass the incoming samples. */
- BiquadFilter_process(&State->mFilter[c].Lp, samples[0], afmt[c], todo);
- BiquadFilter_process(&State->mFilter[c].Hp, samples[1], samples[0], todo);
+ BiquadFilter_process(&mFilter[c].Lp, samples[0], afmt[c], todo);
+ BiquadFilter_process(&mFilter[c].Hp, samples[1], samples[0], todo);
/* Feed the initial delay line. */
- DelayLineIn(&State->mDelay, offset, c, samples[1], todo);
+ DelayLineIn(&mDelay, offset, c, samples[1], todo);
}
if(UNLIKELY(fadeCount < FADE_SAMPLES))
@@ -1502,21 +1490,21 @@ static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const
ALfloat fade = (ALfloat)fadeCount;
/* Generate early reflections. */
- EarlyReflection_Faded(State, offset, todo, fade, samples);
+ EarlyReflection_Faded(this, offset, todo, fade, samples);
/* Mix the A-Format results to output, implicitly converting back
* to B-Format.
*/
for(c = 0;c < NUM_LINES;c++)
MixSamples(samples[c], NumChannels, SamplesOut,
- State->mEarly.CurrentGain[c], State->mEarly.PanGain[c],
+ mEarly.CurrentGain[c], mEarly.PanGain[c],
SamplesToDo-base, base, todo
);
/* Generate and mix late reverb. */
- LateReverb_Faded(State, offset, todo, fade, samples);
+ LateReverb_Faded(this, offset, todo, fade, samples);
for(c = 0;c < NUM_LINES;c++)
MixSamples(samples[c], NumChannels, SamplesOut,
- State->mLate.CurrentGain[c], State->mLate.PanGain[c],
+ mLate.CurrentGain[c], mLate.PanGain[c],
SamplesToDo-base, base, todo
);
@@ -1528,35 +1516,35 @@ static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const
fadeCount = FADE_SAMPLES;
for(c = 0;c < NUM_LINES;c++)
{
- State->mEarlyDelayTap[c][0] = State->mEarlyDelayTap[c][1];
- State->mEarlyDelayCoeff[c][0] = State->mEarlyDelayCoeff[c][1];
- State->mEarly.VecAp.Offset[c][0] = State->mEarly.VecAp.Offset[c][1];
- State->mEarly.Offset[c][0] = State->mEarly.Offset[c][1];
- State->mEarly.Coeff[c][0] = State->mEarly.Coeff[c][1];
- State->mLateDelayTap[c][0] = State->mLateDelayTap[c][1];
- State->mLate.VecAp.Offset[c][0] = State->mLate.VecAp.Offset[c][1];
- State->mLate.Offset[c][0] = State->mLate.Offset[c][1];
- State->mLate.T60[c].MidGain[0] = State->mLate.T60[c].MidGain[1];
+ mEarlyDelayTap[c][0] = mEarlyDelayTap[c][1];
+ mEarlyDelayCoeff[c][0] = mEarlyDelayCoeff[c][1];
+ mEarly.VecAp.Offset[c][0] = mEarly.VecAp.Offset[c][1];
+ mEarly.Offset[c][0] = mEarly.Offset[c][1];
+ mEarly.Coeff[c][0] = mEarly.Coeff[c][1];
+ mLateDelayTap[c][0] = mLateDelayTap[c][1];
+ mLate.VecAp.Offset[c][0] = mLate.VecAp.Offset[c][1];
+ mLate.Offset[c][0] = mLate.Offset[c][1];
+ mLate.T60[c].MidGain[0] = mLate.T60[c].MidGain[1];
}
- State->mLate.DensityGain[0] = State->mLate.DensityGain[1];
- State->mMaxUpdate[0] = State->mMaxUpdate[1];
+ mLate.DensityGain[0] = mLate.DensityGain[1];
+ mMaxUpdate[0] = mMaxUpdate[1];
}
}
else
{
/* Generate and mix early reflections. */
- EarlyReflection_Unfaded(State, offset, todo, samples);
+ EarlyReflection_Unfaded(this, offset, todo, samples);
for(c = 0;c < NUM_LINES;c++)
MixSamples(samples[c], NumChannels, SamplesOut,
- State->mEarly.CurrentGain[c], State->mEarly.PanGain[c],
+ mEarly.CurrentGain[c], mEarly.PanGain[c],
SamplesToDo-base, base, todo
);
/* Generate and mix late reverb. */
- LateReverb_Unfaded(State, offset, todo, samples);
+ LateReverb_Unfaded(this, offset, todo, samples);
for(c = 0;c < NUM_LINES;c++)
MixSamples(samples[c], NumChannels, SamplesOut,
- State->mLate.CurrentGain[c], State->mLate.PanGain[c],
+ mLate.CurrentGain[c], mLate.PanGain[c],
SamplesToDo-base, base, todo
);
}
@@ -1566,21 +1554,17 @@ static ALvoid ReverbState_process(ReverbState *State, ALsizei SamplesToDo, const
base += todo;
}
- State->mOffset = offset;
- State->mFadeCount = fadeCount;
+ mOffset = offset;
+ mFadeCount = fadeCount;
}
struct ReverbStateFactory final : public EffectStateFactory {
- ALeffectState *create() override;
+ EffectState *create() override;
};
-ALeffectState *ReverbStateFactory::create()
-{
- ReverbState *state;
- NEW_OBJ0(state, ReverbState)();
- return state;
-}
+EffectState *ReverbStateFactory::create()
+{ return new ReverbState{}; }
EffectStateFactory *ReverbStateFactory_getFactory(void)
{
diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h
index d3d4e704..ca2cb663 100644
--- a/OpenAL32/Include/alAuxEffectSlot.h
+++ b/OpenAL32/Include/alAuxEffectSlot.h
@@ -8,58 +8,31 @@
#include "atomic.h"
-struct ALeffectStateVtable;
struct ALeffectslot;
-typedef struct ALeffectState {
- RefCount Ref;
- const struct ALeffectStateVtable *vtbl;
- ALfloat (*OutBuffer)[BUFFERSIZE];
- ALsizei OutChannels;
-} ALeffectState;
+struct EffectState {
+ RefCount mRef{1u};
-void ALeffectState_Construct(ALeffectState *state);
-void ALeffectState_Destruct(ALeffectState *state);
+ ALfloat (*mOutBuffer)[BUFFERSIZE]{nullptr};
+ ALsizei mOutChannels{0};
-struct ALeffectStateVtable {
- void (*const Destruct)(ALeffectState *state);
- ALboolean (*const deviceUpdate)(ALeffectState *state, ALCdevice *device);
- void (*const update)(ALeffectState *state, const ALCcontext *context, const struct ALeffectslot *slot, const union ALeffectProps *props);
- void (*const process)(ALeffectState *state, ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels);
+ virtual ~EffectState() = default;
- void (*const Delete)(void *ptr);
-};
+ virtual ALboolean deviceUpdate(ALCdevice *device) = 0;
+ virtual void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props) = 0;
+ virtual void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], ALsizei numChannels) = 0;
-/* Small hack to use a pointer-to-array types as a normal argument type.
- * Shouldn't be used directly.
- */
-typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
-
-#define DEFINE_ALEFFECTSTATE_VTABLE(T) \
-DECLARE_THUNK(T, ALeffectState, void, Destruct) \
-DECLARE_THUNK1(T, ALeffectState, ALboolean, deviceUpdate, ALCdevice*) \
-DECLARE_THUNK3(T, ALeffectState, void, update, const ALCcontext*, const ALeffectslot*, const ALeffectProps*) \
-DECLARE_THUNK4(T, ALeffectState, void, process, ALsizei, const ALfloatBUFFERSIZE*RESTRICT, ALfloatBUFFERSIZE*RESTRICT, ALsizei) \
-static void T##_ALeffectState_Delete(void *ptr) \
-{ return T##_Delete(STATIC_UPCAST(T, ALeffectState, (ALeffectState*)ptr)); } \
- \
-static const struct ALeffectStateVtable T##_ALeffectState_vtable = { \
- T##_ALeffectState_Destruct, \
- \
- T##_ALeffectState_deviceUpdate, \
- T##_ALeffectState_update, \
- T##_ALeffectState_process, \
- \
- T##_ALeffectState_Delete, \
-}
+ void IncRef() noexcept;
+ void DecRef() noexcept;
+};
struct EffectStateFactory {
virtual ~EffectStateFactory() { }
- virtual ALeffectState *create() = 0;
+ virtual EffectState *create() = 0;
};
@@ -79,7 +52,7 @@ struct ALeffectslotProps {
ALenum Type;
ALeffectProps Props;
- ALeffectState *State;
+ EffectState *State;
ATOMIC(struct ALeffectslotProps*) next;
};
@@ -93,7 +66,7 @@ struct ALeffectslot {
ALenum Type{AL_EFFECT_NULL};
ALeffectProps Props{};
- ALeffectState *State{nullptr};
+ EffectState *State{nullptr};
} Effect;
ATOMIC(ALenum) PropsClean{AL_TRUE};
@@ -108,7 +81,7 @@ struct ALeffectslot {
ALenum EffectType{AL_EFFECT_NULL};
ALeffectProps EffectProps{};
- ALeffectState *EffectState{nullptr};
+ EffectState *EffectState{nullptr};
ALfloat RoomRolloff{0.0f}; /* Added to the source's room rolloff, not multiplied. */
ALfloat DecayTime{0.0f};
@@ -167,6 +140,4 @@ EffectStateFactory *DedicatedStateFactory_getFactory(void);
ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
-void ALeffectState_DecRef(ALeffectState *state);
-
#endif
diff --git a/OpenAL32/Include/alMain.h b/OpenAL32/Include/alMain.h
index 64297592..8f08d94a 100644
--- a/OpenAL32/Include/alMain.h
+++ b/OpenAL32/Include/alMain.h
@@ -206,6 +206,7 @@ struct ALCbackend;
struct ALbuffer;
struct ALeffect;
struct ALfilter;
+struct EffectState;
#define DEFAULT_OUTPUT_RATE (44100)
@@ -755,7 +756,7 @@ typedef struct AsyncEvent {
ALuint param;
ALchar msg[1008];
} user;
- struct ALeffectState *EffectState;
+ EffectState *mEffectState;
} u;
} AsyncEvent;
#define ASYNC_EVENT(t) { t, { 0 } }
diff --git a/OpenAL32/alAuxEffectSlot.cpp b/OpenAL32/alAuxEffectSlot.cpp
index 4e25d3ee..cab9e43d 100644
--- a/OpenAL32/alAuxEffectSlot.cpp
+++ b/OpenAL32/alAuxEffectSlot.cpp
@@ -74,8 +74,6 @@ static inline EffectStateFactory *getFactoryByType(ALenum type)
return nullptr;
}
-static void ALeffectState_IncRef(ALeffectState *state);
-
static inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id)
{
@@ -483,7 +481,7 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
ALCdevice *Device = Context->Device;
ALenum newtype = (effect ? effect->type : AL_EFFECT_NULL);
struct ALeffectslotProps *props;
- ALeffectState *State;
+ EffectState *State;
if(newtype != EffectSlot->Effect.Type)
{
@@ -498,13 +496,13 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
START_MIXER_MODE();
almtx_lock(&Device->BackendLock);
- State->OutBuffer = Device->Dry.Buffer;
- State->OutChannels = Device->Dry.NumChannels;
- if(V(State,deviceUpdate)(Device) == AL_FALSE)
+ State->mOutBuffer = Device->Dry.Buffer;
+ State->mOutChannels = Device->Dry.NumChannels;
+ if(State->deviceUpdate(Device) == AL_FALSE)
{
almtx_unlock(&Device->BackendLock);
LEAVE_MIXER_MODE();
- ALeffectState_DecRef(State);
+ State->DecRef();
return AL_OUT_OF_MEMORY;
}
almtx_unlock(&Device->BackendLock);
@@ -521,7 +519,7 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
EffectSlot->Effect.Props = effect->Props;
}
- ALeffectState_DecRef(EffectSlot->Effect.State);
+ EffectSlot->Effect.State->DecRef();
EffectSlot->Effect.State = State;
}
else if(effect)
@@ -532,7 +530,7 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
while(props)
{
if(props->State)
- ALeffectState_DecRef(props->State);
+ props->State->DecRef();
props->State = nullptr;
props = ATOMIC_LOAD(&props->next, almemory_order_relaxed);
}
@@ -541,30 +539,17 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
}
-static void ALeffectState_IncRef(ALeffectState *state)
+void EffectState::IncRef() noexcept
{
- auto ref = IncrementRef(&state->Ref);
- TRACEREF("%p increasing refcount to %u\n", state, ref);
-}
-
-void ALeffectState_DecRef(ALeffectState *state)
-{
- auto ref = DecrementRef(&state->Ref);
- TRACEREF("%p decreasing refcount to %u\n", state, ref);
- if(ref == 0) DELETE_OBJ(state);
-}
-
-
-void ALeffectState_Construct(ALeffectState *state)
-{
- InitRef(&state->Ref, 1);
-
- state->OutBuffer = nullptr;
- state->OutChannels = 0;
+ auto ref = IncrementRef(&mRef);
+ TRACEREF("%p increasing refcount to %u\n", this, ref);
}
-void ALeffectState_Destruct(ALeffectState *UNUSED(state))
+void EffectState::DecRef() noexcept
{
+ auto ref = DecrementRef(&mRef);
+ TRACEREF("%p decreasing refcount to %u\n", this, ref);
+ if(ref == 0) delete this;
}
@@ -664,7 +649,7 @@ ALenum InitEffectSlot(ALeffectslot *slot)
slot->Effect.State = factory->create();
if(!slot->Effect.State) return AL_OUT_OF_MEMORY;
- ALeffectState_IncRef(slot->Effect.State);
+ slot->Effect.State->IncRef();
slot->Params.EffectState = slot->Effect.State;
return AL_NO_ERROR;
}
@@ -674,21 +659,21 @@ ALeffectslot::~ALeffectslot()
struct ALeffectslotProps *props{Update.load()};
if(props)
{
- if(props->State) ALeffectState_DecRef(props->State);
+ if(props->State) props->State->DecRef();
TRACE("Freed unapplied AuxiliaryEffectSlot update %p\n", props);
al_free(props);
}
if(Effect.State)
- ALeffectState_DecRef(Effect.State);
+ Effect.State->DecRef();
if(Params.EffectState)
- ALeffectState_DecRef(Params.EffectState);
+ Params.EffectState->DecRef();
}
void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
{
struct ALeffectslotProps *props;
- ALeffectState *oldstate;
+ EffectState *oldstate;
/* Get an unused property container, or allocate a new one as needed. */
props = context->FreeEffectslotProps.load(std::memory_order_relaxed);
@@ -712,7 +697,7 @@ void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
/* Swap out any stale effect state object there may be in the container, to
* delete it.
*/
- ALeffectState_IncRef(slot->Effect.State);
+ slot->Effect.State->IncRef();
oldstate = props->State;
props->State = slot->Effect.State;
@@ -724,13 +709,13 @@ void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context)
* freelist.
*/
if(props->State)
- ALeffectState_DecRef(props->State);
+ props->State->DecRef();
props->State = nullptr;
AtomicReplaceHead(context->FreeEffectslotProps, props);
}
if(oldstate)
- ALeffectState_DecRef(oldstate);
+ oldstate->DecRef();
}
void UpdateAllEffectSlotProps(ALCcontext *context)
diff --git a/OpenAL32/event.cpp b/OpenAL32/event.cpp
index 1dc2745f..d6fa01fb 100644
--- a/OpenAL32/event.cpp
+++ b/OpenAL32/event.cpp
@@ -34,7 +34,7 @@ static int EventThread(ALCcontext *context)
if(evt.EnumType == EventType_ReleaseEffectState)
{
- ALeffectState_DecRef(evt.u.EffectState);
+ evt.u.mEffectState->DecRef();
continue;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 06:52:26 +0000