Fix up the naming convention of effect methods

9 files changed, 148 insertions, 148 deletions

diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c
index 2c3aa742..cec6f435 100644
--- a/Alc/effects/chorus.c
+++ b/Alc/effects/chorus.c
@@ -66,7 +66,7 @@ static ALvoid ALchorusState_Destruct(ALchorusState *state)
     state->SampleBufferRight = NULL;
 }
 
-static ALboolean ALchorusState_DeviceUpdate(ALchorusState *state, ALCdevice *Device)
+static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device)
 {
     ALuint maxlen;
     ALuint it;
@@ -98,7 +98,7 @@ static ALboolean ALchorusState_DeviceUpdate(ALchorusState *state, ALCdevice *Dev
     return AL_TRUE;
 }
 
-static ALvoid ALchorusState_Update(ALchorusState *state, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALchorusState_update(ALchorusState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
     ALfloat frequency = (ALfloat)Device->Frequency;
     ALfloat rate;
@@ -235,7 +235,7 @@ DECL_TEMPLATE(Sinusoid)
 
 #undef DECL_TEMPLATE
 
-static ALvoid ALchorusState_Process(ALchorusState *state, 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])
 {
     if(state->waveform == AL_CHORUS_WAVEFORM_TRIANGLE)
         ProcessTriangle(state, SamplesToDo, SamplesIn, SamplesOut);
@@ -284,7 +284,7 @@ ALeffectStateFactory *ALchorusStateFactory_getFactory(void)
 }
 
 
-void ALchorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALchorus_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -305,11 +305,11 @@ void ALchorus_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALchorus_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALchorus_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALchorus_SetParami(effect, context, param, vals[0]);
+    ALchorus_setParami(effect, context, param, vals[0]);
 }
-void ALchorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALchorus_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -342,12 +342,12 @@ void ALchorus_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALchorus_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALchorus_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALchorus_SetParamf(effect, context, param, vals[0]);
+    ALchorus_setParamf(effect, context, param, vals[0]);
 }
 
-void ALchorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALchorus_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -364,11 +364,11 @@ void ALchorus_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALchorus_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALchorus_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALchorus_GetParami(effect, context, param, vals);
+    ALchorus_getParami(effect, context, param, vals);
 }
-void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALchorus_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -393,9 +393,9 @@ void ALchorus_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALchorus_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALchorus_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALchorus_GetParamf(effect, context, param, vals);
+    ALchorus_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALchorus);
diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c
index 4d3485fb..8be7fee6 100644
--- a/Alc/effects/dedicated.c
+++ b/Alc/effects/dedicated.c
@@ -48,14 +48,14 @@ static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state)
     (void)state;
 }
 
-static ALboolean ALdedicatedState_DeviceUpdate(ALdedicatedState *state, ALCdevice *Device)
+static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *Device)
 {
     return AL_TRUE;
     (void)state;
     (void)Device;
 }
 
-static ALvoid ALdedicatedState_Update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot)
+static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot)
 {
     ALfloat Gain;
     ALsizei s;
@@ -70,7 +70,7 @@ static ALvoid ALdedicatedState_Update(ALdedicatedState *state, ALCdevice *device
         state->gains[LFE] = Gain;
 }
 
-static ALvoid ALdedicatedState_Process(ALdedicatedState *state, 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])
 {
     const ALfloat *gains = state->gains;
     ALuint i, c;
@@ -125,13 +125,13 @@ ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void)
 }
 
 
-void ALdedicated_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALdedicated_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALdedicated_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALdedicated_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALdedicated_SetParami(effect, context, param, vals[0]);
+    ALdedicated_setParami(effect, context, param, vals[0]);
 }
-void ALdedicated_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALdedicated_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -146,18 +146,18 @@ void ALdedicated_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALdedicated_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALdedicated_SetParamf(effect, context, param, vals[0]);
+    ALdedicated_setParamf(effect, context, param, vals[0]);
 }
 
-void ALdedicated_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALdedicated_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALdedicated_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALdedicated_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALdedicated_GetParami(effect, context, param, vals);
+    ALdedicated_getParami(effect, context, param, vals);
 }
-void ALdedicated_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALdedicated_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -170,9 +170,9 @@ void ALdedicated_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALdedicated_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALdedicated_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALdedicated_GetParamf(effect, context, param, vals);
+    ALdedicated_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALdedicated);
diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c
index 84440cce..4fd116f6 100644
--- a/Alc/effects/distortion.c
+++ b/Alc/effects/distortion.c
@@ -72,14 +72,14 @@ static ALvoid ALdistortionState_Destruct(ALdistortionState *state)
     (void)state;
 }
 
-static ALboolean ALdistortionState_DeviceUpdate(ALdistortionState *state, ALCdevice *device)
+static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device)
 {
     return AL_TRUE;
     (void)state;
     (void)device;
 }
 
-static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
     ALfloat gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
     ALfloat frequency = (ALfloat)Device->Frequency;
@@ -132,7 +132,7 @@ static ALvoid ALdistortionState_Update(ALdistortionState *state, ALCdevice *Devi
     state->bandpass.a[2] = 1.0f - alpha;
 }
 
-static ALvoid ALdistortionState_Process(ALdistortionState *state, 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])
 {
     const ALfloat fc = state->edge_coeff;
     float oversample_buffer[64][4];
@@ -280,13 +280,13 @@ ALeffectStateFactory *ALdistortionStateFactory_getFactory(void)
 }
 
 
-void ALdistortion_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALdistortion_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALdistortion_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALdistortion_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALdistortion_SetParami(effect, context, param, vals[0]);
+    ALdistortion_setParami(effect, context, param, vals[0]);
 }
-void ALdistortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALdistortion_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -325,18 +325,18 @@ void ALdistortion_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALdistortion_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALdistortion_SetParamf(effect, context, param, vals[0]);
+    ALdistortion_setParamf(effect, context, param, vals[0]);
 }
 
-void ALdistortion_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALdistortion_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALdistortion_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALdistortion_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALdistortion_GetParami(effect, context, param, vals);
+    ALdistortion_getParami(effect, context, param, vals);
 }
-void ALdistortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALdistortion_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -365,9 +365,9 @@ void ALdistortion_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALdistortion_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALdistortion_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALdistortion_GetParamf(effect, context, param, vals);
+    ALdistortion_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALdistortion);
diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c
index 9d17ead0..29087439 100644
--- a/Alc/effects/echo.c
+++ b/Alc/effects/echo.c
@@ -63,7 +63,7 @@ static ALvoid ALechoState_Destruct(ALechoState *state)
     state->SampleBuffer = NULL;
 }
 
-static ALboolean ALechoState_DeviceUpdate(ALechoState *state, ALCdevice *Device)
+static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
 {
     ALuint maxlen, i;
 
@@ -89,7 +89,7 @@ static ALboolean ALechoState_DeviceUpdate(ALechoState *state, ALCdevice *Device)
     return AL_TRUE;
 }
 
-static ALvoid ALechoState_Update(ALechoState *state, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALechoState_update(ALechoState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
     ALuint frequency = Device->Frequency;
     ALfloat lrpan, gain;
@@ -124,7 +124,7 @@ static ALvoid ALechoState_Update(ALechoState *state, ALCdevice *Device, const AL
     ComputeAngleGains(Device, atan2f(+lrpan, 0.0f), (1.0f-dirGain)*F_PI, gain, state->Gain[1]);
 }
 
-static ALvoid ALechoState_Process(ALechoState *state, 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])
 {
     const ALuint mask = state->BufferLength-1;
     const ALuint tap1 = state->Tap[0].delay;
@@ -220,13 +220,13 @@ ALeffectStateFactory *ALechoStateFactory_getFactory(void)
 }
 
 
-void ALecho_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALecho_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALecho_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALecho_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALecho_SetParami(effect, context, param, vals[0]);
+    ALecho_setParami(effect, context, param, vals[0]);
 }
-void ALecho_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALecho_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -265,18 +265,18 @@ void ALecho_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALecho_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALecho_SetParamf(effect, context, param, vals[0]);
+    ALecho_setParamf(effect, context, param, vals[0]);
 }
 
-void ALecho_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALecho_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALecho_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALecho_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALecho_GetParami(effect, context, param, vals);
+    ALecho_getParami(effect, context, param, vals);
 }
-void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALecho_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -305,9 +305,9 @@ void ALecho_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALecho_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALecho_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALecho_GetParamf(effect, context, param, vals);
+    ALecho_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALecho);
diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c
index 0a26cda7..467dbbbc 100644
--- a/Alc/effects/equalizer.c
+++ b/Alc/effects/equalizer.c
@@ -93,14 +93,14 @@ static ALvoid ALequalizerState_Destruct(ALequalizerState *state)
     (void)state;
 }
 
-static ALboolean ALequalizerState_DeviceUpdate(ALequalizerState *state, ALCdevice *device)
+static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device)
 {
     return AL_TRUE;
     (void)state;
     (void)device;
 }
 
-static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot)
+static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot)
 {
     ALfloat frequency = (ALfloat)device->Frequency;
     ALfloat gain = sqrtf(1.0f / device->NumChan) * slot->Gain;
@@ -153,7 +153,7 @@ static ALvoid ALequalizerState_Update(ALequalizerState *state, ALCdevice *device
     }
 }
 
-static ALvoid ALequalizerState_Process(ALequalizerState *state, 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])
 {
     ALuint base;
     ALuint it;
@@ -231,13 +231,13 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void)
 }
 
 
-void ALequalizer_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALequalizer_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALequalizer_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALequalizer_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALequalizer_SetParami(effect, context, param, vals[0]);
+    ALequalizer_setParami(effect, context, param, vals[0]);
 }
-void ALequalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALequalizer_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -306,18 +306,18 @@ void ALequalizer_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALequalizer_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALequalizer_SetParamf(effect, context, param, vals[0]);
+    ALequalizer_setParamf(effect, context, param, vals[0]);
 }
 
-void ALequalizer_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALequalizer_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
-void ALequalizer_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALequalizer_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALequalizer_GetParami(effect, context, param, vals);
+    ALequalizer_getParami(effect, context, param, vals);
 }
-void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALequalizer_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -366,9 +366,9 @@ void ALequalizer_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALequalizer_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALequalizer_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALequalizer_GetParamf(effect, context, param, vals);
+    ALequalizer_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALequalizer);
diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c
index 86b067d5..e9de888a 100644
--- a/Alc/effects/flanger.c
+++ b/Alc/effects/flanger.c
@@ -66,7 +66,7 @@ static ALvoid ALflangerState_Destruct(ALflangerState *state)
     state->SampleBufferRight = NULL;
 }
 
-static ALboolean ALflangerState_DeviceUpdate(ALflangerState *state, ALCdevice *Device)
+static ALboolean ALflangerState_deviceUpdate(ALflangerState *state, ALCdevice *Device)
 {
     ALuint maxlen;
     ALuint it;
@@ -98,7 +98,7 @@ static ALboolean ALflangerState_DeviceUpdate(ALflangerState *state, ALCdevice *D
     return AL_TRUE;
 }
 
-static ALvoid ALflangerState_Update(ALflangerState *state, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALflangerState_update(ALflangerState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
     ALfloat frequency = (ALfloat)Device->Frequency;
     ALfloat rate;
@@ -235,7 +235,7 @@ DECL_TEMPLATE(Sinusoid)
 
 #undef DECL_TEMPLATE
 
-static ALvoid ALflangerState_Process(ALflangerState *state, 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])
 {
     if(state->waveform == AL_FLANGER_WAVEFORM_TRIANGLE)
         ProcessTriangle(state, SamplesToDo, SamplesIn, SamplesOut);
@@ -284,7 +284,7 @@ ALeffectStateFactory *ALflangerStateFactory_getFactory(void)
 }
 
 
-void ALflanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALflanger_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -305,11 +305,11 @@ void ALflanger_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALflanger_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALflanger_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALflanger_SetParami(effect, context, param, vals[0]);
+    ALflanger_setParami(effect, context, param, vals[0]);
 }
-void ALflanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALflanger_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -342,12 +342,12 @@ void ALflanger_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALflanger_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALflanger_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALflanger_SetParamf(effect, context, param, vals[0]);
+    ALflanger_setParamf(effect, context, param, vals[0]);
 }
 
-void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALflanger_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -364,11 +364,11 @@ void ALflanger_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, AL
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALflanger_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALflanger_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALflanger_GetParami(effect, context, param, vals);
+    ALflanger_getParami(effect, context, param, vals);
 }
-void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALflanger_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -393,9 +393,9 @@ void ALflanger_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, AL
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALflanger_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALflanger_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALflanger_GetParamf(effect, context, param, vals);
+    ALflanger_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALflanger);
diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c
index d253614c..356f0fd6 100644
--- a/Alc/effects/modulator.c
+++ b/Alc/effects/modulator.c
@@ -126,14 +126,14 @@ static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state)
     (void)state;
 }
 
-static ALboolean ALmodulatorState_DeviceUpdate(ALmodulatorState *state, ALCdevice *Device)
+static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *Device)
 {
     return AL_TRUE;
     (void)state;
     (void)Device;
 }
 
-static ALvoid ALmodulatorState_Update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot)
 {
     ALfloat gain, cw, a;
     ALuint index;
@@ -172,7 +172,7 @@ static ALvoid ALmodulatorState_Update(ALmodulatorState *state, ALCdevice *Device
     }
 }
 
-static ALvoid ALmodulatorState_Process(ALmodulatorState *state, 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])
 {
     switch(state->Waveform)
     {
@@ -231,7 +231,7 @@ ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void)
 }
 
 
-void ALmodulator_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALmodulator_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -252,18 +252,18 @@ void ALmodulator_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALmodulator_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALmodulator_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALmodulator_SetParamf(effect, context, param, vals[0]);
+    ALmodulator_setParamf(effect, context, param, vals[0]);
 }
-void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALmodulator_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
     {
         case AL_RING_MODULATOR_FREQUENCY:
         case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
-            ALmodulator_SetParamf(effect, context, param, (ALfloat)val);
+            ALmodulator_setParamf(effect, context, param, (ALfloat)val);
             break;
 
         case AL_RING_MODULATOR_WAVEFORM:
@@ -276,12 +276,12 @@ void ALmodulator_SetParami(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALmodulator_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALmodulator_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALmodulator_SetParami(effect, context, param, vals[0]);
+    ALmodulator_setParami(effect, context, param, vals[0]);
 }
 
-void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALmodulator_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -300,11 +300,11 @@ void ALmodulator_GetParami(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALmodulator_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALmodulator_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALmodulator_GetParami(effect, context, param, vals);
+    ALmodulator_getParami(effect, context, param, vals);
 }
-void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALmodulator_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -320,9 +320,9 @@ void ALmodulator_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALmodulator_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALmodulator_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALmodulator_GetParamf(effect, context, param, vals);
+    ALmodulator_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALmodulator);
diff --git a/Alc/effects/null.c b/Alc/effects/null.c
index f7262ca5..fe9ea41d 100644
--- a/Alc/effects/null.c
+++ b/Alc/effects/null.c
@@ -31,7 +31,7 @@ static ALvoid ALnullState_Destruct(ALnullState *state)
  * initialization and any time the device parameters (eg. playback frequency,
  * format) have been changed.
  */
-static ALboolean ALnullState_DeviceUpdate(ALnullState *state, ALCdevice *device)
+static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device)
 {
     return AL_TRUE;
     (void)state;
@@ -41,7 +41,7 @@ static ALboolean ALnullState_DeviceUpdate(ALnullState *state, ALCdevice *device)
 /* This updates the effect state. This is called any time the effect is
  * (re)loaded into a slot.
  */
-static ALvoid ALnullState_Update(ALnullState *state, ALCdevice *device, const ALeffectslot *slot)
+static ALvoid ALnullState_update(ALnullState *state, ALCdevice *device, const ALeffectslot *slot)
 {
     (void)state;
     (void)device;
@@ -52,7 +52,7 @@ static ALvoid ALnullState_Update(ALnullState *state, ALCdevice *device, const AL
  * input to the output buffer. The result should be added to the output buffer,
  * not replace it.
  */
-static ALvoid ALnullState_Process(ALnullState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE])
+static ALvoid ALnullState_process(ALnullState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE])
 {
     (void)state;
     (void)samplesToDo;
@@ -101,7 +101,7 @@ ALeffectStateFactory *ALnullStateFactory_getFactory(void)
 }
 
 
-void ALnull_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALnull_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 {
     (void)effect;
     (void)val;
@@ -111,7 +111,7 @@ void ALnull_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALnull_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
     (void)effect;
     (void)vals;
@@ -121,7 +121,7 @@ void ALnull_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, cons
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALnull_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     (void)effect;
     (void)val;
@@ -131,7 +131,7 @@ void ALnull_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALnull_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
     (void)effect;
     (void)vals;
@@ -142,7 +142,7 @@ void ALnull_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons
     }
 }
 
-void ALnull_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALnull_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 {
     (void)effect;
     (void)val;
@@ -152,7 +152,7 @@ void ALnull_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALnull_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
     (void)effect;
     (void)vals;
@@ -162,7 +162,7 @@ void ALnull_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALin
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALnull_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     (void)effect;
     (void)val;
@@ -172,7 +172,7 @@ void ALnull_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALflo
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALnull_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
     (void)effect;
     (void)vals;
diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c
index e17a0833..1fb30610 100644
--- a/Alc/effects/reverb.c
+++ b/Alc/effects/reverb.c
@@ -561,7 +561,7 @@ static inline ALvoid EAXVerbPass(ALreverbState *State, ALfloat in, ALfloat *rest
     State->Offset++;
 }
 
-static ALvoid ALreverbState_ProcessStandard(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+static ALvoid ALreverbState_processStandard(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
 {
     ALfloat (*restrict out)[4] = State->ReverbSamples;
     ALuint index, c;
@@ -581,7 +581,7 @@ static ALvoid ALreverbState_ProcessStandard(ALreverbState *State, ALuint Samples
     }
 }
 
-static ALvoid ALreverbState_ProcessEax(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+static ALvoid ALreverbState_processEax(ALreverbState *State, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
 {
     ALfloat (*restrict early)[4] = State->EarlySamples;
     ALfloat (*restrict late)[4] = State->ReverbSamples;
@@ -609,12 +609,12 @@ static ALvoid ALreverbState_ProcessEax(ALreverbState *State, ALuint SamplesToDo,
     }
 }
 
-static ALvoid ALreverbState_Process(ALreverbState *State, 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])
 {
     if(State->IsEax)
-        ALreverbState_ProcessEax(State, SamplesToDo, SamplesIn, SamplesOut);
+        ALreverbState_processEax(State, SamplesToDo, SamplesIn, SamplesOut);
     else
-        ALreverbState_ProcessStandard(State, SamplesToDo, SamplesIn, SamplesOut);
+        ALreverbState_processStandard(State, SamplesToDo, SamplesIn, SamplesOut);
 }
 
 // Given the allocated sample buffer, this function updates each delay line
@@ -731,7 +731,7 @@ static ALboolean AllocLines(ALuint frequency, ALreverbState *State)
     return AL_TRUE;
 }
 
-static ALboolean ALreverbState_DeviceUpdate(ALreverbState *State, ALCdevice *Device)
+static ALboolean ALreverbState_deviceUpdate(ALreverbState *State, ALCdevice *Device)
 {
     ALuint frequency = Device->Frequency, index;
 
@@ -1080,7 +1080,7 @@ static ALvoid Update3DPanning(const ALCdevice *Device, const ALfloat *Reflection
                       lerp(ambientGain, 1.0f, dirGain) * Gain, State->Late.PanGain);
 }
 
-static ALvoid ALreverbState_Update(ALreverbState *State, ALCdevice *Device, const ALeffectslot *Slot)
+static ALvoid ALreverbState_update(ALreverbState *State, ALCdevice *Device, const ALeffectslot *Slot)
 {
     ALuint frequency = Device->Frequency;
     ALfloat freq_scale, cw, x, y, hfRatio;
@@ -1291,7 +1291,7 @@ ALeffectStateFactory *ALreverbStateFactory_getFactory(void)
 }
 
 
-void ALeaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALeaxreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1306,11 +1306,11 @@ void ALeaxreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALeaxreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALeaxreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALeaxreverb_SetParami(effect, context, param, vals[0]);
+    ALeaxreverb_setParami(effect, context, param, vals[0]);
 }
-void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALeaxreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1439,7 +1439,7 @@ void ALeaxreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALeaxreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1464,12 +1464,12 @@ void ALeaxreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param,
             break;
 
         default:
-            ALeaxreverb_SetParamf(effect, context, param, vals[0]);
+            ALeaxreverb_setParamf(effect, context, param, vals[0]);
             break;
     }
 }
 
-void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALeaxreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1482,11 +1482,11 @@ void ALeaxreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALeaxreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALeaxreverb_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALeaxreverb_GetParami(effect, context, param, vals);
+    ALeaxreverb_getParami(effect, context, param, vals);
 }
-void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALeaxreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1575,7 +1575,7 @@ void ALeaxreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param,
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALeaxreverb_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1596,14 +1596,14 @@ void ALeaxreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param,
             break;
 
         default:
-            ALeaxreverb_GetParamf(effect, context, param, vals);
+            ALeaxreverb_getParamf(effect, context, param, vals);
             break;
     }
 }
 
 DEFINE_ALEFFECT_VTABLE(ALeaxreverb);
 
-void ALreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1618,11 +1618,11 @@ void ALreverb_SetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALreverb_SetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
-    ALreverb_SetParami(effect, context, param, vals[0]);
+    ALreverb_setParami(effect, context, param, vals[0]);
 }
-void ALreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 {
     ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1703,12 +1703,12 @@ void ALreverb_SetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALreverb_SetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
-    ALreverb_SetParamf(effect, context, param, vals[0]);
+    ALreverb_setParamf(effect, context, param, vals[0]);
 }
 
-void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+void ALreverb_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1721,11 +1721,11 @@ void ALreverb_GetParami(ALeffect *effect, ALCcontext *context, ALenum param, ALi
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALreverb_GetParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALreverb_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
-    ALreverb_GetParami(effect, context, param, vals);
+    ALreverb_getParami(effect, context, param, vals);
 }
-void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALreverb_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 {
     const ALeffectProps *props = &effect->Props;
     switch(param)
@@ -1782,9 +1782,9 @@ void ALreverb_GetParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALf
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALreverb_GetParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALreverb_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
-    ALreverb_GetParamf(effect, context, param, vals);
+    ALreverb_getParamf(effect, context, param, vals);
 }
 
 DEFINE_ALEFFECT_VTABLE(ALreverb);