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 /* Forward-declare "virtual" functions to define the vtable with. */
  17 static ALvoid ALnullState_Destruct(ALnullState *state);
  18 static ALboolean ALnullState_deviceUpdate(ALnullState *state, ALCdevice *device);
  19 static ALvoid ALnullState_update(ALnullState *state, const ALCdevice *device, const ALeffectslot *slot, const ALeffectProps *props);
  20 static ALvoid ALnullState_process(ALnullState *state, ALuint samplesToDo, const ALfloatBUFFERSIZE*restrict samplesIn, ALfloatBUFFERSIZE*restrict samplesOut, ALuint NumChannels);
  21 static void *ALnullState_New(size_t size);
  22 static void ALnullState_Delete(void *ptr);
  23
  24 /* Define the ALeffectState vtable for this type. */
  25 DEFINE_ALEFFECTSTATE_VTABLE(ALnullState);
  26
  27
  28 /* This constructs the effect state. It's called when the object is first
  29  * created. Make sure to call the parent Construct function first, and set the
  30  * vtable!
  31  */
  32 static void ALnullState_Construct(ALnullState *state)
  33 {
  34     ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
  35     SET_VTABLE2(ALnullState, ALeffectState, state);
  36 }
  37
  38 /* This destructs (not free!) the effect state. It's called only when the
  39  * effect slot is no longer used. Make sure to call the parent Destruct
  40  * function before returning!
  41  */
  42 static ALvoid ALnullState_Destruct(ALnullState *state)
  43 {
  44     ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
  45 }
  46
  47 /* This updates the device-dependant effect state. This is called on
  48  * initialization and any time the device parameters (eg. playback frequency,
  49  * format) have been changed.
  50  */
  51 static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device))
  52 {
  53     return AL_TRUE;
  54 }
  55
  56 /* This updates the effect state. This is called any time the effect is
  57  * (re)loaded into a slot.
  58  */
  59 static ALvoid ALnullState_update(ALnullState* UNUSED(state), const ALCdevice* UNUSED(device), const ALeffectslot* UNUSED(slot), const ALeffectProps* UNUSED(props))
  60 {
  61 }
  62
  63 /* This processes the effect state, for the given number of samples from the
  64  * input to the output buffer. The result should be added to the output buffer,
  65  * not replace it.
  66  */
  67 static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALuint UNUSED(samplesToDo), const ALfloatBUFFERSIZE*restrict UNUSED(samplesIn), ALfloatBUFFERSIZE*restrict UNUSED(samplesOut), ALuint UNUSED(NumChannels))
  68 {
  69 }
  70
  71 /* This allocates memory to store the object, before it gets constructed.
  72  * DECLARE_DEFAULT_ALLOCATORS can be used to declare a default method.
  73  */
  74 static void *ALnullState_New(size_t size)
  75 {
  76     return al_malloc(16, size);
  77 }
  78
  79 /* This frees the memory used by the object, after it has been destructed.
  80  * DECLARE_DEFAULT_ALLOCATORS can be used to declare a default method.
  81  */
  82 static void ALnullState_Delete(void *ptr)
  83 {
  84     al_free(ptr);
  85 }
  86
  87
  88 typedef struct ALnullStateFactory {
  89     DERIVE_FROM_TYPE(ALeffectStateFactory);
  90 } ALnullStateFactory;
  91
  92 /* Creates ALeffectState objects of the appropriate type. */
  93 ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory))
  94 {
  95     ALnullState *state;
  96
  97     NEW_OBJ0(state, ALnullState)();
  98     if(!state) return NULL;
  99
 100     return STATIC_CAST(ALeffectState, state);
 101 }
 102
 103 /* Define the ALeffectStateFactory vtable for this type. */
 104 DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALnullStateFactory);
 105
 106 ALeffectStateFactory *ALnullStateFactory_getFactory(void)
 107 {
 108     static ALnullStateFactory NullFactory = { { GET_VTABLE2(ALnullStateFactory, ALeffectStateFactory) } };
 109     return STATIC_CAST(ALeffectStateFactory, &NullFactory);
 110 }
 111
 112
 113 void ALnull_setParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
 114 {
 115     switch(param)
 116     {
 117         default:
 118             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 119     }
 120 }
 121 void ALnull_setParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALint* UNUSED(vals))
 122 {
 123     switch(param)
 124     {
 125         default:
 126             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 127     }
 128 }
 129 void ALnull_setParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
 130 {
 131     switch(param)
 132     {
 133         default:
 134             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 135     }
 136 }
 137 void ALnull_setParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat* UNUSED(vals))
 138 {
 139     switch(param)
 140     {
 141         default:
 142             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 143     }
 144 }
 145
 146 void ALnull_getParami(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val))
 147 {
 148     switch(param)
 149     {
 150         default:
 151             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 152     }
 153 }
 154 void ALnull_getParamiv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals))
 155 {
 156     switch(param)
 157     {
 158         default:
 159             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 160     }
 161 }
 162 void ALnull_getParamf(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val))
 163 {
 164     switch(param)
 165     {
 166         default:
 167             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 168     }
 169 }
 170 void ALnull_getParamfv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals))
 171 {
 172     switch(param)
 173     {
 174         default:
 175             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 176     }
 177 }
 178
 179 DEFINE_ALEFFECT_VTABLE(ALnull);