Fix up the naming convention of effect methods

16 files changed, 195 insertions, 192 deletions

diff --git a/Alc/ALc.c b/Alc/ALc.c
index 975fe661..4d60278f 100644
--- a/Alc/ALc.c
+++ b/Alc/ALc.c
@@ -1707,7 +1707,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
         {
             ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
 
-            if(VCALL(slot->EffectState,DeviceUpdate,(device)) == AL_FALSE)
+            if(VCALL(slot->EffectState,deviceUpdate,(device)) == AL_FALSE)
             {
                 UnlockUIntMapRead(&context->EffectSlotMap);
                 ALCdevice_Unlock(device);
@@ -1715,7 +1715,7 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
                 return ALC_INVALID_DEVICE;
             }
             slot->NeedsUpdate = AL_FALSE;
-            VCALL(slot->EffectState,Update,(device, slot));
+            VCALL(slot->EffectState,update,(device, slot));
         }
         UnlockUIntMapRead(&context->EffectSlotMap);
 
@@ -1744,14 +1744,14 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
     {
         ALeffectslot *slot = device->DefaultSlot;
 
-        if(VCALL(slot->EffectState,DeviceUpdate,(device)) == AL_FALSE)
+        if(VCALL(slot->EffectState,deviceUpdate,(device)) == AL_FALSE)
         {
             ALCdevice_Unlock(device);
             RestoreFPUMode(&oldMode);
             return ALC_INVALID_DEVICE;
         }
         slot->NeedsUpdate = AL_FALSE;
-        VCALL(slot->EffectState,Update,(device, slot));
+        VCALL(slot->EffectState,update,(device, slot));
     }
     ALCdevice_Unlock(device);
     RestoreFPUMode(&oldMode);
diff --git a/Alc/ALu.c b/Alc/ALu.c
index 35ed986c..dd7392fc 100644
--- a/Alc/ALu.c
+++ b/Alc/ALu.c
@@ -1042,9 +1042,9 @@ ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
                 (*slot)->PendingClicks[0] = 0.0f;
 
                 if(!DeferUpdates && ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
-                    VCALL((*slot)->EffectState,Update,(device, *slot));
+                    VCALL((*slot)->EffectState,update,(device, *slot));
 
-                VCALL((*slot)->EffectState,Process,(SamplesToDo, (*slot)->WetBuffer[0],
+                VCALL((*slot)->EffectState,process,(SamplesToDo, (*slot)->WetBuffer[0],
                                                     device->DryBuffer));
 
                 for(i = 0;i < SamplesToDo;i++)
@@ -1071,9 +1071,9 @@ ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
             (*slot)->PendingClicks[0] = 0.0f;
 
             if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
-                VCALL((*slot)->EffectState,Update,(device, *slot));
+                VCALL((*slot)->EffectState,update,(device, *slot));
 
-            VCALL((*slot)->EffectState,Process,(SamplesToDo, (*slot)->WetBuffer[0],
+            VCALL((*slot)->EffectState,process,(SamplesToDo, (*slot)->WetBuffer[0],
                                                 device->DryBuffer));
 
             for(i = 0;i < SamplesToDo;i++)
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);
diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h
index 60724654..463a6770 100644
--- a/OpenAL32/Include/alAuxEffectSlot.h
+++ b/OpenAL32/Include/alAuxEffectSlot.h
@@ -15,9 +15,10 @@ typedef struct ALeffectslot ALeffectslot;
 
 struct ALeffectStateVtable {
     ALvoid (*const Destruct)(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]);
+
+    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]);
 
     void (*const Delete)(ALeffectState *state);
 };
@@ -29,20 +30,22 @@ struct ALeffectState {
 #define DEFINE_ALEFFECTSTATE_VTABLE(T)                                        \
 static ALvoid T##_ALeffectState_Destruct(ALeffectState *state)                \
 { T##_Destruct(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 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 ALvoid T##_ALeffectState_Delete(ALeffectState *state)                  \
 { T##_Delete(STATIC_UPCAST(T, ALeffectState, state)); }                       \
                                                                               \
 static const struct ALeffectStateVtable T##_ALeffectState_vtable = {          \
     T##_ALeffectState_Destruct,                                               \
-    T##_ALeffectState_DeviceUpdate,                                           \
-    T##_ALeffectState_Update,                                                 \
-    T##_ALeffectState_Process,                                                \
+                                                                              \
+    T##_ALeffectState_deviceUpdate,                                           \
+    T##_ALeffectState_update,                                                 \
+    T##_ALeffectState_process,                                                \
+                                                                              \
     T##_ALeffectState_Delete,                                                 \
 }
 
diff --git a/OpenAL32/Include/alEffect.h b/OpenAL32/Include/alEffect.h
index a1b430e9..8b7b612f 100644
--- a/OpenAL32/Include/alEffect.h
+++ b/OpenAL32/Include/alEffect.h
@@ -28,23 +28,23 @@ extern ALfloat ReverbBoost;
 extern ALboolean EmulateEAXReverb;
 
 struct ALeffectVtable {
-    void (*const SetParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint val);
-    void (*const SetParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals);
-    void (*const SetParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val);
-    void (*const SetParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals);
-
-    void (*const GetParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val);
-    void (*const GetParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals);
-    void (*const GetParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val);
-    void (*const GetParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals);
+    void (*const setParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint val);
+    void (*const setParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals);
+    void (*const setParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val);
+    void (*const setParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals);
+
+    void (*const getParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val);
+    void (*const getParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals);
+    void (*const getParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val);
+    void (*const getParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals);
 };
 
 #define DEFINE_ALEFFECT_VTABLE(T)           \
 const struct ALeffectVtable T##_vtable = {  \
-    T##_SetParami, T##_SetParamiv,          \
-    T##_SetParamf, T##_SetParamfv,          \
-    T##_GetParami, T##_GetParamiv,          \
-    T##_GetParamf, T##_GetParamfv,          \
+    T##_setParami, T##_setParamiv,          \
+    T##_setParamf, T##_setParamfv,          \
+    T##_getParami, T##_getParamiv,          \
+    T##_getParamf, T##_getParamfv,          \
 }
 
 extern const struct ALeffectVtable ALeaxreverb_vtable;
diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c
index 99cac58e..b3d0d826 100644
--- a/OpenAL32/alAuxEffectSlot.c
+++ b/OpenAL32/alAuxEffectSlot.c
@@ -496,7 +496,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e
         SetMixerFPUMode(&oldMode);
 
         ALCdevice_Lock(Device);
-        if(VCALL(State,DeviceUpdate,(Device)) == AL_FALSE)
+        if(VCALL(State,deviceUpdate,(Device)) == AL_FALSE)
         {
             ALCdevice_Unlock(Device);
             RestoreFPUMode(&oldMode);
@@ -520,7 +520,7 @@ ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *e
          * object was changed, it needs an update before its Process method can
          * be called. */
         EffectSlot->NeedsUpdate = AL_FALSE;
-        VCALL(EffectSlot->EffectState,Update,(Device, EffectSlot));
+        VCALL(EffectSlot->EffectState,update,(Device, EffectSlot));
         ALCdevice_Unlock(Device);
 
         RestoreFPUMode(&oldMode);
diff --git a/OpenAL32/alEffect.c b/OpenAL32/alEffect.c
index 425d2b60..b67e34ae 100644
--- a/OpenAL32/alEffect.c
+++ b/OpenAL32/alEffect.c
@@ -167,7 +167,7 @@ AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
         else
         {
             /* Call the appropriate handler */
-            VCALL(ALEffect,SetParami,(Context, param, value));
+            VCALL(ALEffect,setParami,(Context, param, value));
         }
     }
 
@@ -196,7 +196,7 @@ AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *v
     else
     {
         /* Call the appropriate handler */
-        VCALL(ALEffect,SetParamiv,(Context, param, values));
+        VCALL(ALEffect,setParamiv,(Context, param, values));
     }
 
     ALCcontext_DecRef(Context);
@@ -217,7 +217,7 @@ AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat value)
     else
     {
         /* Call the appropriate handler */
-        VCALL(ALEffect,SetParamf,(Context, param, value));
+        VCALL(ALEffect,setParamf,(Context, param, value));
     }
 
     ALCcontext_DecRef(Context);
@@ -238,7 +238,7 @@ AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat
     else
     {
         /* Call the appropriate handler */
-        VCALL(ALEffect,SetParamfv,(Context, param, values));
+        VCALL(ALEffect,setParamfv,(Context, param, values));
     }
 
     ALCcontext_DecRef(Context);
@@ -263,7 +263,7 @@ AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value
         else
         {
             /* Call the appropriate handler */
-            VCALL(ALEffect,GetParami,(Context, param, value));
+            VCALL(ALEffect,getParami,(Context, param, value));
         }
     }
 
@@ -292,7 +292,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *valu
     else
     {
         /* Call the appropriate handler */
-        VCALL(ALEffect,GetParamiv,(Context, param, values));
+        VCALL(ALEffect,getParamiv,(Context, param, values));
     }
 
     ALCcontext_DecRef(Context);
@@ -313,7 +313,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *val
     else
     {
         /* Call the appropriate handler */
-        VCALL(ALEffect,GetParamf,(Context, param, value));
+        VCALL(ALEffect,getParamf,(Context, param, value));
     }
 
     ALCcontext_DecRef(Context);
@@ -334,7 +334,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *va
     else
     {
         /* Call the appropriate handler */
-        VCALL(ALEffect,GetParamfv,(Context, param, values));
+        VCALL(ALEffect,getParamfv,(Context, param, values));
     }
 
     ALCcontext_DecRef(Context);
diff --git a/OpenAL32/alState.c b/OpenAL32/alState.c
index ab39afed..f56dc98d 100644
--- a/OpenAL32/alState.c
+++ b/OpenAL32/alState.c
@@ -625,7 +625,7 @@ AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void)
         while(slot != slot_end)
         {
             if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
-                VCALL((*slot)->EffectState,Update,(Context->Device, *slot));
+                VCALL((*slot)->EffectState,update,(Context->Device, *slot));
             slot++;
         }