Use the UNUSED macro in the effects

11 files changed, 60 insertions, 110 deletions

diff --git a/Alc/effects/autowah.c b/Alc/effects/autowah.c
index ffec3c9c..e6e45273 100644
--- a/Alc/effects/autowah.c
+++ b/Alc/effects/autowah.c
@@ -66,16 +66,13 @@ typedef struct ALautowahState {
     ALfilterState high_pass;
 } ALautowahState;
 
-static ALvoid ALautowahState_Destruct(ALautowahState *state)
+static ALvoid ALautowahState_Destruct(ALautowahState *UNUSED(state))
 {
-    (void)state;
 }
 
-static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *device)
+static ALboolean ALautowahState_deviceUpdate(ALautowahState *UNUSED(state), ALCdevice *UNUSED(device))
 {
     return AL_TRUE;
-    (void)state;
-    (void)device;
 }
 
 static ALvoid ALautowahState_update(ALautowahState *state, ALCdevice *Device, const ALeffectslot *Slot)
@@ -174,10 +171,9 @@ static void ALautowahState_Delete(ALautowahState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState);
 
 
-static ALeffectState *ALautowahStateFactory_create(ALautowahStateFactory *factory)
+static ALeffectState *ALautowahStateFactory_create(ALautowahStateFactory *UNUSED(factory))
 {
     ALautowahState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
@@ -198,8 +194,8 @@ ALeffectStateFactory *ALautowahStateFactory_getFactory(void)
 }
 
 
-void ALautowah_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
-{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
+void ALautowah_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALautowah_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
     ALautowah_setParami(effect, context, param, vals[0]);
@@ -244,8 +240,8 @@ void ALautowah_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, c
     ALautowah_setParamf(effect, context, param, vals[0]);
 }
 
-void ALautowah_getParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
-{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val; }
+void ALautowah_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALautowah_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
     ALautowah_getParami(effect, context, param, vals);
diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c
index 8fc82a7f..9e889847 100644
--- a/Alc/effects/chorus.c
+++ b/Alc/effects/chorus.c
@@ -244,10 +244,9 @@ static void ALchorusState_Delete(ALchorusState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState);
 
 
-static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *factory)
+static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(factory))
 {
     ALchorusState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c
index 46673f45..4bee76ce 100644
--- a/Alc/effects/compressor.c
+++ b/Alc/effects/compressor.c
@@ -47,9 +47,8 @@ typedef struct ALcompressorState {
     ALfloat Release;
 } ALcompressorState;
 
-static ALvoid ALcompressorState_Destruct(ALcompressorState *state)
+static ALvoid ALcompressorState_Destruct(ALcompressorState *UNUSED(state))
 {
-    (void)state;
 }
 
 static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device)
@@ -139,10 +138,9 @@ static void ALcompressorState_Delete(ALcompressorState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState);
 
 
-static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *factory)
+static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *UNUSED(factory))
 {
     ALcompressorState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
@@ -181,8 +179,8 @@ void ALcompressor_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param
     ALcompressor_setParami(effect, context, param, vals[0]);
 }
 
-void ALcompressor_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
-{SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val;}
+void ALcompressor_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 
 void ALcompressor_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 {
@@ -205,8 +203,8 @@ void ALcompressor_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param
 {
     ALcompressor_getParami(effect, context, param, vals);
 }
-void ALcompressor_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
-{SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); (void)effect;(void)param;(void)val;}
+void ALcompressor_getParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 
 void ALcompressor_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 {
diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c
index 5a9842fa..3ce41978 100644
--- a/Alc/effects/dedicated.c
+++ b/Alc/effects/dedicated.c
@@ -43,16 +43,13 @@ typedef struct ALdedicatedState {
 } ALdedicatedState;
 
 
-static ALvoid ALdedicatedState_Destruct(ALdedicatedState *state)
+static ALvoid ALdedicatedState_Destruct(ALdedicatedState *UNUSED(state))
 {
-    (void)state;
 }
 
-static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *state, ALCdevice *Device)
+static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *UNUSED(state), ALCdevice *UNUSED(device))
 {
     return AL_TRUE;
-    (void)state;
-    (void)Device;
 }
 
 static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot)
@@ -94,11 +91,10 @@ static void ALdedicatedState_Delete(ALdedicatedState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState);
 
 
-ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *factory)
+ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(factory))
 {
     ALdedicatedState *state;
     ALsizei s;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
@@ -126,8 +122,8 @@ ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void)
 }
 
 
-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_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALdedicated_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
     ALdedicated_setParami(effect, context, param, vals[0]);
@@ -152,8 +148,8 @@ void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param,
     ALdedicated_setParamf(effect, context, param, vals[0]);
 }
 
-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_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALdedicated_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
     ALdedicated_getParami(effect, context, param, vals);
diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c
index 9a18ad46..4ceb9648 100644
--- a/Alc/effects/distortion.c
+++ b/Alc/effects/distortion.c
@@ -50,16 +50,13 @@ typedef struct ALdistortionState {
     ALfloat edge_coeff;
 } ALdistortionState;
 
-static ALvoid ALdistortionState_Destruct(ALdistortionState *state)
+static ALvoid ALdistortionState_Destruct(ALdistortionState *UNUSED(state))
 {
-    (void)state;
 }
 
-static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *state, ALCdevice *device)
+static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *UNUSED(state), ALCdevice *UNUSED(device))
 {
     return AL_TRUE;
-    (void)state;
-    (void)device;
 }
 
 static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot)
@@ -188,10 +185,9 @@ static void ALdistortionState_Delete(ALdistortionState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState);
 
 
-static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *factory)
+static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *UNUSED(factory))
 {
     ALdistortionState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
@@ -219,8 +215,8 @@ ALeffectStateFactory *ALdistortionStateFactory_getFactory(void)
 }
 
 
-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_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALdistortion_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
     ALdistortion_setParami(effect, context, param, vals[0]);
@@ -269,8 +265,8 @@ void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param
     ALdistortion_setParamf(effect, context, param, vals[0]);
 }
 
-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_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALdistortion_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
     ALdistortion_getParami(effect, context, param, vals);
diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c
index a9110e35..1305921c 100644
--- a/Alc/effects/echo.c
+++ b/Alc/effects/echo.c
@@ -176,10 +176,9 @@ static void ALechoState_Delete(ALechoState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALechoState);
 
 
-ALeffectState *ALechoStateFactory_create(ALechoStateFactory *factory)
+ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory))
 {
     ALechoState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
@@ -213,8 +212,8 @@ ALeffectStateFactory *ALechoStateFactory_getFactory(void)
 }
 
 
-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_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALecho_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
     ALecho_setParami(effect, context, param, vals[0]);
@@ -263,8 +262,8 @@ void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, cons
     ALecho_setParamf(effect, context, param, vals[0]);
 }
 
-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_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALecho_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
     ALecho_getParami(effect, context, param, vals);
diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c
index b7bfa0a2..7b3b508d 100644
--- a/Alc/effects/equalizer.c
+++ b/Alc/effects/equalizer.c
@@ -88,16 +88,13 @@ typedef struct ALequalizerState {
     ALfilterState filter[4];
 } ALequalizerState;
 
-static ALvoid ALequalizerState_Destruct(ALequalizerState *state)
+static ALvoid ALequalizerState_Destruct(ALequalizerState *UNUSED(state))
 {
-    (void)state;
 }
 
-static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *state, ALCdevice *device)
+static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *UNUSED(state), ALCdevice *UNUSED(device))
 {
     return AL_TRUE;
-    (void)state;
-    (void)device;
 }
 
 static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot)
@@ -173,11 +170,10 @@ static void ALequalizerState_Delete(ALequalizerState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState);
 
 
-ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *factory)
+ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(factory))
 {
     ALequalizerState *state;
     int it;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
@@ -207,8 +203,8 @@ ALeffectStateFactory *ALequalizerStateFactory_getFactory(void)
 }
 
 
-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_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALequalizer_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 {
     ALequalizer_setParami(effect, context, param, vals[0]);
@@ -287,8 +283,8 @@ void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param,
     ALequalizer_setParamf(effect, context, param, vals[0]);
 }
 
-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_getParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 void ALequalizer_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 {
     ALequalizer_getParami(effect, context, param, vals);
diff --git a/Alc/effects/flanger.c b/Alc/effects/flanger.c
index 0107afed..25a13934 100644
--- a/Alc/effects/flanger.c
+++ b/Alc/effects/flanger.c
@@ -244,10 +244,9 @@ static void ALflangerState_Delete(ALflangerState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALflangerState);
 
 
-ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *factory)
+ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factory))
 {
     ALflangerState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c
index b71070f5..2a3049d9 100644
--- a/Alc/effects/modulator.c
+++ b/Alc/effects/modulator.c
@@ -121,16 +121,13 @@ DECL_TEMPLATE(Square)
 #undef DECL_TEMPLATE
 
 
-static ALvoid ALmodulatorState_Destruct(ALmodulatorState *state)
+static ALvoid ALmodulatorState_Destruct(ALmodulatorState *UNUSED(state))
 {
-    (void)state;
 }
 
-static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *state, ALCdevice *Device)
+static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *UNUSED(state), ALCdevice *UNUSED(device))
 {
     return AL_TRUE;
-    (void)state;
-    (void)Device;
 }
 
 static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot)
@@ -190,10 +187,9 @@ static void ALmodulatorState_Delete(ALmodulatorState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState);
 
 
-static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *factory)
+static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UNUSED(factory))
 {
     ALmodulatorState *state;
-    (void)factory;
 
     state = malloc(sizeof(*state));
     if(!state) return NULL;
diff --git a/Alc/effects/null.c b/Alc/effects/null.c
index fe9ea41d..62e9f6eb 100644
--- a/Alc/effects/null.c
+++ b/Alc/effects/null.c
@@ -22,41 +22,34 @@ static ALnullStateFactory NullFactory;
 /* This destructs (not free!) the effect state. It's called only when the
  * effect slot is no longer used.
  */
-static ALvoid ALnullState_Destruct(ALnullState *state)
+static ALvoid ALnullState_Destruct(ALnullState* UNUSED(state))
 {
-    (void)state;
 }
 
 /* This updates the device-dependant effect state. This is called on
  * initialization and any time the device parameters (eg. playback frequency,
  * format) have been changed.
  */
-static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device)
+static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device))
 {
     return AL_TRUE;
-    (void)state;
-    (void)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* UNUSED(state), ALCdevice* UNUSED(device), const ALeffectslot* UNUSED(slot))
 {
-    (void)state;
-    (void)device;
-    (void)slot;
 }
 
 /* This processes the effect state, for the given number of samples from the
  * 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* UNUSED(state), ALuint UNUSED(samplesToDo), const ALfloat *restrict UNUSED(samplesIn), ALfloat (*restrict samplesOut)[BUFFERSIZE])
 {
-    (void)state;
-    (void)samplesToDo;
-    (void)samplesIn;
+    /* NOTE: Couldn't use the UNUSED macro on samplesOut due to the way GCC's
+     * __attribute__ declaration interacts with the parenthesis. */
     (void)samplesOut;
 }
 
@@ -71,10 +64,9 @@ DEFINE_ALEFFECTSTATE_VTABLE(ALnullState);
 
 
 /* Creates ALeffectState objects of the appropriate type. */
-ALeffectState *ALnullStateFactory_create(ALnullStateFactory *factory)
+ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory))
 {
     ALnullState *state;
-    (void)factory;
 
     state = calloc(1, sizeof(*state));
     if(!state) return NULL;
@@ -101,40 +93,32 @@ ALeffectStateFactory *ALnullStateFactory_getFactory(void)
 }
 
 
-void ALnull_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+void ALnull_setParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
 {
-    (void)effect;
-    (void)val;
     switch(param)
     {
         default:
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+void ALnull_setParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALint* UNUSED(vals))
 {
-    (void)effect;
-    (void)vals;
     switch(param)
     {
         default:
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+void ALnull_setParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
 {
-    (void)effect;
-    (void)val;
     switch(param)
     {
         default:
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+void ALnull_setParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat* UNUSED(vals))
 {
-    (void)effect;
-    (void)vals;
     switch(param)
     {
         default:
@@ -142,40 +126,32 @@ 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* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val))
 {
-    (void)effect;
-    (void)val;
     switch(param)
     {
         default:
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_getParamiv(ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+void ALnull_getParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals))
 {
-    (void)effect;
-    (void)vals;
     switch(param)
     {
         default:
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_getParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+void ALnull_getParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val))
 {
-    (void)effect;
-    (void)val;
     switch(param)
     {
         default:
             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
     }
 }
-void ALnull_getParamfv(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+void ALnull_getParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals))
 {
-    (void)effect;
-    (void)vals;
     switch(param)
     {
         default:
diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c
index 4c65e0a6..9e16984b 100644
--- a/Alc/effects/reverb.c
+++ b/Alc/effects/reverb.c
@@ -1185,11 +1185,10 @@ static void ALreverbState_Delete(ALreverbState *state)
 DEFINE_ALEFFECTSTATE_VTABLE(ALreverbState);
 
 
-static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory *factory)
+static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory* UNUSED(factory))
 {
     ALreverbState *state;
     ALuint index;
-    (void)factory;
 
     state = malloc(sizeof(ALreverbState));
     if(!state) return NULL;