Auto-generate wrappers to upcast objects before calling user methods

10 files changed, 58 insertions, 87 deletions

diff --git a/Alc/alcChorus.c b/Alc/alcChorus.c
index c34396eb..ff1c9492 100644
--- a/Alc/alcChorus.c
+++ b/Alc/alcChorus.c
@@ -50,10 +50,8 @@ typedef struct ALchorusState {
     ALfloat feedback;
 } ALchorusState;
 
-static ALvoid ALchorusState_Destroy(ALeffectState *effect)
+static ALvoid ALchorusState_Destroy(ALchorusState *state)
 {
-    ALchorusState *state = STATIC_UPCAST(ALchorusState, ALeffectState, effect);
-
     free(state->SampleBufferLeft);
     state->SampleBufferLeft = NULL;
 
@@ -63,9 +61,8 @@ static ALvoid ALchorusState_Destroy(ALeffectState *effect)
     free(state);
 }
 
-static ALboolean ALchorusState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALchorusState_DeviceUpdate(ALchorusState *state, ALCdevice *Device)
 {
-    ALchorusState *state = STATIC_UPCAST(ALchorusState, ALeffectState, effect);
     ALuint maxlen;
     ALuint it;
 
@@ -96,9 +93,8 @@ static ALboolean ALchorusState_DeviceUpdate(ALeffectState *effect, ALCdevice *De
     return AL_TRUE;
 }
 
-static ALvoid ALchorusState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALchorusState_Update(ALchorusState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALchorusState *state = STATIC_UPCAST(ALchorusState, ALeffectState, effect);
     ALfloat frequency = Device->Frequency;
     ALfloat rate;
     ALint phase;
@@ -234,10 +230,8 @@ DECL_TEMPLATE(Sinusoid)
 
 #undef DECL_TEMPLATE
 
-static ALvoid ALchorusState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALchorusState_Process(ALchorusState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALchorusState *state = STATIC_UPCAST(ALchorusState, ALeffectState, effect);
-
     if(state->waveform == AL_CHORUS_WAVEFORM_TRIANGLE)
         ProcessTriangle(state, SamplesToDo, SamplesIn, SamplesOut);
     else if(state->waveform == AL_CHORUS_WAVEFORM_SINUSOID)
diff --git a/Alc/alcDedicated.c b/Alc/alcDedicated.c
index a3267509..7d32c153 100644
--- a/Alc/alcDedicated.c
+++ b/Alc/alcDedicated.c
@@ -36,22 +36,20 @@ typedef struct ALdedicatedState {
 } ALdedicatedState;
 
 
-static ALvoid ALdedicatedState_Destroy(ALeffectState *effect)
+static ALvoid ALdedicatedState_Destroy(ALdedicatedState *state)
 {
-    ALdedicatedState *state = STATIC_UPCAST(ALdedicatedState, ALeffectState, effect);
     free(state);
 }
 
-static ALboolean ALdedicatedState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALdedicatedState_DeviceUpdate(ALdedicatedState *state, ALCdevice *Device)
 {
-    (void)effect;
-    (void)Device;
     return AL_TRUE;
+    (void)state;
+    (void)Device;
 }
 
-static ALvoid ALdedicatedState_Update(ALeffectState *effect, ALCdevice *device, const ALeffectslot *Slot)
+static ALvoid ALdedicatedState_Update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot)
 {
-    ALdedicatedState *state = STATIC_UPCAST(ALdedicatedState, ALeffectState, effect);
     ALfloat Gain;
     ALsizei s;
 
@@ -65,9 +63,8 @@ static ALvoid ALdedicatedState_Update(ALeffectState *effect, ALCdevice *device,
         state->gains[LFE] = Gain;
 }
 
-static ALvoid ALdedicatedState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALdedicatedState_Process(ALdedicatedState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALdedicatedState *state = STATIC_UPCAST(ALdedicatedState, ALeffectState, effect);
     const ALfloat *gains = state->gains;
     ALuint i, c;
 
diff --git a/Alc/alcDistortion.c b/Alc/alcDistortion.c
index 50627093..8c0f5e97 100644
--- a/Alc/alcDistortion.c
+++ b/Alc/alcDistortion.c
@@ -59,22 +59,20 @@ typedef struct ALdistortionState {
     ALfloat edge_coeff;
 } ALdistortionState;
 
-static ALvoid ALdistortionState_Destroy(ALeffectState *effect)
+static ALvoid ALdistortionState_Destroy(ALdistortionState *state)
 {
-    ALdistortionState *state = STATIC_UPCAST(ALdistortionState, ALeffectState, effect);
     free(state);
 }
 
-static ALboolean ALdistortionState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALdistortionState_DeviceUpdate(ALdistortionState *state, ALCdevice *Device)
 {
     return AL_TRUE;
-    (void)effect;
+    (void)state;
     (void)Device;
 }
 
-static ALvoid ALdistortionState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALdistortionState *state = STATIC_UPCAST(ALdistortionState, ALeffectState, effect);
     ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
     ALfloat frequency = (ALfloat)Device->Frequency;
     ALuint it;
@@ -126,9 +124,8 @@ static ALvoid ALdistortionState_Update(ALeffectState *effect, ALCdevice *Device,
     state->bandpass.a[2] = 1.0f - alpha;
 }
 
-static ALvoid ALdistortionState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALdistortionState_Process(ALdistortionState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALdistortionState *state = STATIC_UPCAST(ALdistortionState, ALeffectState, effect);
     const ALfloat fc = state->edge_coeff;
     float oversample_buffer[64][4];
     ALfloat tempsmp;
diff --git a/Alc/alcEcho.c b/Alc/alcEcho.c
index 3fbd5232..ada61c96 100644
--- a/Alc/alcEcho.c
+++ b/Alc/alcEcho.c
@@ -51,19 +51,16 @@ typedef struct ALechoState {
     ALfloat history[2];
 } ALechoState;
 
-static ALvoid ALechoState_Destroy(ALeffectState *effect)
+static ALvoid ALechoState_Destroy(ALechoState *state)
 {
-    ALechoState *state = STATIC_UPCAST(ALechoState, ALeffectState, effect);
-
     free(state->SampleBuffer);
     state->SampleBuffer = NULL;
 
     free(state);
 }
 
-static ALboolean ALechoState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALechoState_DeviceUpdate(ALechoState *state, ALCdevice *Device)
 {
-    ALechoState *state = STATIC_UPCAST(ALechoState, ALeffectState, effect);
     ALuint maxlen, i;
 
     // Use the next power of 2 for the buffer length, so the tap offsets can be
@@ -88,9 +85,8 @@ static ALboolean ALechoState_DeviceUpdate(ALeffectState *effect, ALCdevice *Devi
     return AL_TRUE;
 }
 
-static ALvoid ALechoState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALechoState_Update(ALechoState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALechoState *state = STATIC_UPCAST(ALechoState, ALeffectState, effect);
     ALuint frequency = Device->Frequency;
     ALfloat lrpan, cw, g, gain;
     ALfloat dirGain;
@@ -124,9 +120,8 @@ static ALvoid ALechoState_Update(ALeffectState *effect, ALCdevice *Device, const
     ComputeAngleGains(Device, atan2f(+lrpan, 0.0f), (1.0f-dirGain)*F_PI, gain, state->Gain[1]);
 }
 
-static ALvoid ALechoState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALechoState_Process(ALechoState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALechoState *state = STATIC_UPCAST(ALechoState, ALeffectState, effect);
     const ALuint mask = state->BufferLength-1;
     const ALuint tap1 = state->Tap[0].delay;
     const ALuint tap2 = state->Tap[1].delay;
diff --git a/Alc/alcEqualizer.c b/Alc/alcEqualizer.c
index 50a83c9a..6bc4ed12 100644
--- a/Alc/alcEqualizer.c
+++ b/Alc/alcEqualizer.c
@@ -95,24 +95,19 @@ typedef struct ALequalizerState {
     ALfloat frequency;
 } ALequalizerState;
 
-static ALvoid ALequalizerState_Destroy(ALeffectState *effect)
+static ALvoid ALequalizerState_Destroy(ALequalizerState *state)
 {
-    ALequalizerState *state = STATIC_UPCAST(ALequalizerState, ALeffectState, effect);
     free(state);
 }
 
-static ALboolean ALequalizerState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALequalizerState_DeviceUpdate(ALequalizerState *state, ALCdevice *Device)
 {
-    ALequalizerState *state = STATIC_UPCAST(ALequalizerState, ALeffectState, effect);
-
     state->frequency = (ALfloat)Device->Frequency;
-
     return AL_TRUE;
 }
 
-static ALvoid ALequalizerState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALequalizerState *state = STATIC_UPCAST(ALequalizerState, ALeffectState, effect);
     ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
     ALuint it;
 
@@ -215,9 +210,8 @@ static ALvoid ALequalizerState_Update(ALeffectState *effect, ALCdevice *Device,
     }
 }
 
-static ALvoid ALequalizerState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALequalizerState_Process(ALequalizerState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALequalizerState *state = STATIC_UPCAST(ALequalizerState, ALeffectState, effect);
     ALuint base;
     ALuint it;
     ALuint kt;
diff --git a/Alc/alcFlanger.c b/Alc/alcFlanger.c
index a69d7006..574fa9d7 100644
--- a/Alc/alcFlanger.c
+++ b/Alc/alcFlanger.c
@@ -50,10 +50,8 @@ typedef struct ALflangerState {
     ALfloat feedback;
 } ALflangerState;
 
-static ALvoid ALflangerState_Destroy(ALeffectState *effect)
+static ALvoid ALflangerState_Destroy(ALflangerState *state)
 {
-    ALflangerState *state = STATIC_UPCAST(ALflangerState, ALeffectState, effect);
-
     free(state->SampleBufferLeft);
     state->SampleBufferLeft = NULL;
 
@@ -63,9 +61,8 @@ static ALvoid ALflangerState_Destroy(ALeffectState *effect)
     free(state);
 }
 
-static ALboolean ALflangerState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALflangerState_DeviceUpdate(ALflangerState *state, ALCdevice *Device)
 {
-    ALflangerState *state = STATIC_UPCAST(ALflangerState, ALeffectState, effect);
     ALuint maxlen;
     ALuint it;
 
@@ -96,9 +93,8 @@ static ALboolean ALflangerState_DeviceUpdate(ALeffectState *effect, ALCdevice *D
     return AL_TRUE;
 }
 
-static ALvoid ALflangerState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALflangerState_Update(ALflangerState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALflangerState *state = STATIC_UPCAST(ALflangerState, ALeffectState, effect);
     ALfloat frequency = Device->Frequency;
     ALfloat rate;
     ALint phase;
@@ -234,10 +230,8 @@ DECL_TEMPLATE(Sinusoid)
 
 #undef DECL_TEMPLATE
 
-static ALvoid ALflangerState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALflangerState_Process(ALflangerState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALflangerState *state = STATIC_UPCAST(ALflangerState, ALeffectState, effect);
-
     if(state->waveform == AL_FLANGER_WAVEFORM_TRIANGLE)
         ProcessTriangle(state, SamplesToDo, SamplesIn, SamplesOut);
     else if(state->waveform == AL_FLANGER_WAVEFORM_SINUSOID)
diff --git a/Alc/alcModulator.c b/Alc/alcModulator.c
index b2ea6642..5d4fdab8 100644
--- a/Alc/alcModulator.c
+++ b/Alc/alcModulator.c
@@ -129,22 +129,20 @@ DECL_TEMPLATE(Square)
 #undef DECL_TEMPLATE
 
 
-static ALvoid ALmodulatorState_Destroy(ALeffectState *effect)
+static ALvoid ALmodulatorState_Destroy(ALmodulatorState *state)
 {
-    ALmodulatorState *state = STATIC_UPCAST(ALmodulatorState, ALeffectState, effect);
     free(state);
 }
 
-static ALboolean ALmodulatorState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALmodulatorState_DeviceUpdate(ALmodulatorState *state, ALCdevice *Device)
 {
     return AL_TRUE;
-    (void)effect;
+    (void)state;
     (void)Device;
 }
 
-static ALvoid ALmodulatorState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALmodulatorState_Update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALmodulatorState *state = STATIC_UPCAST(ALmodulatorState, ALeffectState, effect);
     ALfloat gain, cw, a = 0.0f;
     ALuint index;
 
@@ -175,10 +173,8 @@ static ALvoid ALmodulatorState_Update(ALeffectState *effect, ALCdevice *Device,
     }
 }
 
-static ALvoid ALmodulatorState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALmodulatorState_Process(ALmodulatorState *state, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALmodulatorState *state = STATIC_UPCAST(ALmodulatorState, ALeffectState, effect);
-
     switch(state->Waveform)
     {
         case SINUSOID:
diff --git a/Alc/alcReverb.c b/Alc/alcReverb.c
index b84dad96..2bed00a5 100644
--- a/Alc/alcReverb.c
+++ b/Alc/alcReverb.c
@@ -606,9 +606,8 @@ static ALvoid ALreverbState_ProcessEax(ALreverbState *State, ALuint SamplesToDo,
     }
 }
 
-static ALvoid ALreverbState_Process(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
+static ALvoid ALreverbState_Process(ALreverbState *State, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE])
 {
-    ALreverbState *State = STATIC_UPCAST(ALreverbState, ALeffectState, effect);
     if(State->IsEax)
         ALreverbState_ProcessEax(State, SamplesToDo, SamplesIn, SamplesOut);
     else
@@ -732,9 +731,8 @@ static ALboolean AllocLines(ALuint frequency, ALreverbState *State)
 // This updates the device-dependant EAX reverb state.  This is called on
 // initialization and any time the device parameters (eg. playback frequency,
 // format) have been changed.
-static ALboolean ALreverbState_DeviceUpdate(ALeffectState *effect, ALCdevice *Device)
+static ALboolean ALreverbState_DeviceUpdate(ALreverbState *State, ALCdevice *Device)
 {
-    ALreverbState *State = STATIC_UPCAST(ALreverbState, ALeffectState, effect);
     ALuint frequency = Device->Frequency, index;
 
     // Allocate the delay lines.
@@ -1084,9 +1082,8 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection
 
 // This updates the EAX reverb state.  This is called any time the EAX reverb
 // effect is loaded into a slot.
-static ALvoid ALreverbState_Update(ALeffectState *effect, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALreverbState_Update(ALreverbState *State, ALCdevice *Device, const ALeffectslot *Slot)
 {
-    ALreverbState *State = STATIC_UPCAST(ALreverbState, ALeffectState, effect);
     ALuint frequency = Device->Frequency;
     ALfloat cw, x, y, hfRatio;
 
@@ -1174,10 +1171,8 @@ static ALvoid ALreverbState_Update(ALeffectState *effect, ALCdevice *Device, con
 
 // This destroys the reverb state.  It should be called only when the effect
 // slot has a different (or no) effect loaded over the reverb effect.
-static ALvoid ALreverbState_Destroy(ALeffectState *effect)
+static ALvoid ALreverbState_Destroy(ALreverbState *State)
 {
-    ALreverbState *State = STATIC_UPCAST(ALreverbState, ALeffectState, effect);
-
     free(State->SampleBuffer);
     State->SampleBuffer = NULL;
 
@@ -1190,7 +1185,7 @@ DEFINE_ALEFFECTSTATE_VTABLE(ALreverbState);
 // effect is loaded into a slot that doesn't already have a reverb effect.
 ALeffectState *ReverbCreate(void)
 {
-    ALreverbState *State = NULL;
+    ALreverbState *State;
     ALuint index;
 
     State = malloc(sizeof(ALreverbState));
diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h
index a891b52a..ed0d1887 100644
--- a/OpenAL32/Include/alAuxEffectSlot.h
+++ b/OpenAL32/Include/alAuxEffectSlot.h
@@ -12,10 +12,10 @@ typedef struct ALeffectState ALeffectState;
 typedef struct ALeffectslot ALeffectslot;
 
 struct ALeffectStateVtable {
-    ALvoid (*const Destroy)(ALeffectState *State);
-    ALboolean (*const DeviceUpdate)(ALeffectState *State, ALCdevice *Device);
-    ALvoid (*const Update)(ALeffectState *State, ALCdevice *Device, const ALeffectslot *Slot);
-    ALvoid (*const Process)(ALeffectState *State, ALuint SamplesToDo, const ALfloat *RESTRICT SamplesIn, ALfloat (*RESTRICT SamplesOut)[BUFFERSIZE]);
+    ALvoid (*const Destroy)(ALeffectState *state);
+    ALboolean (*const DeviceUpdate)(ALeffectState *state, ALCdevice *device);
+    ALvoid (*const Update)(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot);
+    ALvoid (*const Process)(ALeffectState *state, ALuint samplesToDo, const ALfloat *RESTRICT samplesIn, ALfloat (*RESTRICT samplesOut)[BUFFERSIZE]);
 };
 
 struct ALeffectState {
@@ -23,11 +23,20 @@ struct ALeffectState {
 };
 
 #define DEFINE_ALEFFECTSTATE_VTABLE(T)                                        \
+static ALvoid T##_ALeffectState_Destroy(ALeffectState *state)                 \
+{ T##_Destroy(STATIC_UPCAST(T, ALeffectState, state)); }                      \
+static ALboolean T##_ALeffectState_DeviceUpdate(ALeffectState *state, ALCdevice *device) \
+{ return T##_DeviceUpdate(STATIC_UPCAST(T, ALeffectState, state), device); }             \
+static ALvoid T##_ALeffectState_Update(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot) \
+{ T##_Update(STATIC_UPCAST(T, ALeffectState, state), device, slot); }                                     \
+static ALvoid T##_ALeffectState_Process(ALeffectState *state, ALuint samplesToDo, const ALfloat *RESTRICT samplesIn, ALfloat (*RESTRICT samplesOut)[BUFFERSIZE]) \
+{ T##_Process(STATIC_UPCAST(T, ALeffectState, state), samplesToDo, samplesIn, samplesOut); }                                                                     \
+                                                                              \
 static const struct ALeffectStateVtable T##_ALeffectState_vtable = {          \
-    T##_Destroy,                                                              \
-    T##_DeviceUpdate,                                                         \
-    T##_Update,                                                               \
-    T##_Process                                                               \
+    T##_ALeffectState_Destroy,                                                \
+    T##_ALeffectState_DeviceUpdate,                                           \
+    T##_ALeffectState_Update,                                                 \
+    T##_ALeffectState_Process                                                 \
 }
 
 #define SET_VTABLE1(T1, obj)  ((obj)->vtbl = &(T1##_vtable))
diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c
index 0932376d..3c31ecb8 100644
--- a/OpenAL32/alAuxEffectSlot.c
+++ b/OpenAL32/alAuxEffectSlot.c
@@ -397,21 +397,21 @@ typedef struct ALnoneState {
     DERIVE_FROM_TYPE(ALeffectState);
 } ALnoneState;
 
-static ALvoid ALnoneState_Destroy(ALeffectState *state)
+static ALvoid ALnoneState_Destroy(ALnoneState *state)
 { free(state); }
-static ALboolean ALnoneState_DeviceUpdate(ALeffectState *state, ALCdevice *device)
+static ALboolean ALnoneState_DeviceUpdate(ALnoneState *state, ALCdevice *device)
 {
     return AL_TRUE;
     (void)state;
     (void)device;
 }
-static ALvoid ALnoneState_Update(ALeffectState *state, ALCdevice *device, const ALeffectslot *slot)
+static ALvoid ALnoneState_Update(ALnoneState *state, ALCdevice *device, const ALeffectslot *slot)
 {
     (void)state;
     (void)device;
     (void)slot;
 }
-static ALvoid ALnoneState_Process(ALeffectState *state, ALuint samplesToDo, const ALfloat *RESTRICT samplesIn, ALfloat (*RESTRICT samplesOut)[BUFFERSIZE])
+static ALvoid ALnoneState_Process(ALnoneState *state, ALuint samplesToDo, const ALfloat *RESTRICT samplesIn, ALfloat (*RESTRICT samplesOut)[BUFFERSIZE])
 {
     (void)state;
     (void)samplesToDo;