Alc/effects/null.c

   1 #include "config.h"
   2
   3 #include <stdlib.h>
   4
   5 #include "AL/al.h"
   6 #include "AL/alc.h"
   7 #include "alMain.h"
   8 #include "alAuxEffectSlot.h"
   9 #include "alError.h"
  10
  11
  12 typedef struct ALnullState {
  13     DERIVE_FROM_TYPE(ALeffectState);
  14 } ALnullState;
  15
  16
  17 /* This destructs (not free!) the effect state. It's called only when the
  18  * effect slot is no longer used.
  19  */
  20 static ALvoid ALnullState_Destruct(ALnullState* UNUSED(state))
  21 {
  22 }
  23
  24 /* This updates the device-dependant effect state. This is called on
  25  * initialization and any time the device parameters (eg. playback frequency,
  26  * format) have been changed.
  27  */
  28 static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device))
  29 {
  30     return AL_TRUE;
  31 }
  32
  33 /* This updates the effect state. This is called any time the effect is
  34  * (re)loaded into a slot.
  35  */
  36 static ALvoid ALnullState_update(ALnullState* UNUSED(state), const ALCdevice* UNUSED(device), const ALeffectslot* UNUSED(slot))
  37 {
  38 }
  39
  40 /* This processes the effect state, for the given number of samples from the
  41  * input to the output buffer. The result should be added to the output buffer,
  42  * not replace it.
  43  */
  44 static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALuint UNUSED(samplesToDo), const ALfloatBUFFERSIZE*restrict UNUSED(samplesIn), ALfloatBUFFERSIZE*restrict UNUSED(samplesOut), ALuint UNUSED(NumChannels))
  45 {
  46 }
  47
  48 /* This allocates memory to store the object, before it gets constructed.
  49  * DECLARE_DEFAULT_ALLOCATORS can be used to declate a default method.
  50  */
  51 static void *ALnullState_New(size_t size)
  52 {
  53     return malloc(size);
  54 }
  55
  56 /* This frees the memory used by the object, after it has been destructed.
  57  * DECLARE_DEFAULT_ALLOCATORS can be used to declate a default method.
  58  */
  59 static void ALnullState_Delete(void *ptr)
  60 {
  61     free(ptr);
  62 }
  63
  64 /* Define the forwards and the ALeffectState vtable for this type. */
  65 DEFINE_ALEFFECTSTATE_VTABLE(ALnullState);
  66
  67
  68 typedef struct ALnullStateFactory {
  69     DERIVE_FROM_TYPE(ALeffectStateFactory);
  70 } ALnullStateFactory;
  71
  72 /* Creates ALeffectState objects of the appropriate type. */
  73 ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory))
  74 {
  75     ALnullState *state;
  76
  77     state = ALnullState_New(sizeof(*state));
  78     if(!state) return NULL;
  79     /* Set vtables for inherited types. */
  80     SET_VTABLE2(ALnullState, ALeffectState, state);
  81
  82     return STATIC_CAST(ALeffectState, state);
  83 }
  84
  85 /* Define the ALeffectStateFactory vtable for this type. */
  86 DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALnullStateFactory);
  87
  88 ALeffectStateFactory *ALnullStateFactory_getFactory(void)
  89 {
  90     static ALnullStateFactory NullFactory = { { GET_VTABLE2(ALnullStateFactory, ALeffectStateFactory) } };
  91
  92     return STATIC_CAST(ALeffectStateFactory, &NullFactory);
  93 }
  94
  95
  96 void ALnull_setParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
  97 {
  98     switch(param)
  99     {
 100         default:
 101             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 102     }
 103 }
 104 void ALnull_setParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALint* UNUSED(vals))
 105 {
 106     switch(param)
 107     {
 108         default:
 109             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 110     }
 111 }
 112 void ALnull_setParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
 113 {
 114     switch(param)
 115     {
 116         default:
 117             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 118     }
 119 }
 120 void ALnull_setParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat* UNUSED(vals))
 121 {
 122     switch(param)
 123     {
 124         default:
 125             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 126     }
 127 }
 128
 129 void ALnull_getParami(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val))
 130 {
 131     switch(param)
 132     {
 133         default:
 134             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 135     }
 136 }
 137 void ALnull_getParamiv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals))
 138 {
 139     switch(param)
 140     {
 141         default:
 142             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 143     }
 144 }
 145 void ALnull_getParamf(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val))
 146 {
 147     switch(param)
 148     {
 149         default:
 150             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 151     }
 152 }
 153 void ALnull_getParamfv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals))
 154 {
 155     switch(param)
 156     {
 157         default:
 158             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 159     }
 160 }
 161
 162 DEFINE_ALEFFECT_VTABLE(ALnull);