OpenAL32/Include/alAuxEffectSlot.h

   1 #ifndef _AL_AUXEFFECTSLOT_H_
   2 #define _AL_AUXEFFECTSLOT_H_
   3
   4 #include "alMain.h"
   5 #include "alEffect.h"
   6
   7 #include "atomic.h"
   8 #include "align.h"
   9
  10 #ifdef __cplusplus
  11 extern "C" {
  12 #endif
  13
  14 struct ALeffectStateVtable;
  15 struct ALeffectslot;
  16
  17 typedef struct ALeffectState {
  18     RefCount Ref;
  19     const struct ALeffectStateVtable *vtbl;
  20
  21     ALfloat (*OutBuffer)[BUFFERSIZE];
  22     ALsizei OutChannels;
  23 } ALeffectState;
  24
  25 void ALeffectState_Construct(ALeffectState *state);
  26 void ALeffectState_Destruct(ALeffectState *state);
  27
  28 struct ALeffectStateVtable {
  29     void (*const Destruct)(ALeffectState *state);
  30
  31     ALboolean (*const deviceUpdate)(ALeffectState *state, ALCdevice *device);
  32     void (*const update)(ALeffectState *state, const ALCcontext *context, const struct ALeffectslot *slot, const union ALeffectProps *props);
  33     void (*const process)(ALeffectState *state, ALsizei samplesToDo, const ALfloat (*restrict samplesIn)[BUFFERSIZE], ALfloat (*restrict samplesOut)[BUFFERSIZE], ALsizei numChannels);
  34
  35     void (*const Delete)(void *ptr);
  36 };
  37
  38 /* Small hack to use a pointer-to-array types as a normal argument type.
  39  * Shouldn't be used directly.
  40  */
  41 typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
  42
  43 #define DEFINE_ALEFFECTSTATE_VTABLE(T)                                        \
  44 DECLARE_THUNK(T, ALeffectState, void, Destruct)                               \
  45 DECLARE_THUNK1(T, ALeffectState, ALboolean, deviceUpdate, ALCdevice*)         \
  46 DECLARE_THUNK3(T, ALeffectState, void, update, const ALCcontext*, const ALeffectslot*, const ALeffectProps*) \
  47 DECLARE_THUNK4(T, ALeffectState, void, process, ALsizei, const ALfloatBUFFERSIZE*restrict, ALfloatBUFFERSIZE*restrict, ALsizei) \
  48 static void T##_ALeffectState_Delete(void *ptr)                               \
  49 { return T##_Delete(STATIC_UPCAST(T, ALeffectState, (ALeffectState*)ptr)); }  \
  50                                                                               \
  51 static const struct ALeffectStateVtable T##_ALeffectState_vtable = {          \
  52     T##_ALeffectState_Destruct,                                               \
  53                                                                               \
  54     T##_ALeffectState_deviceUpdate,                                           \
  55     T##_ALeffectState_update,                                                 \
  56     T##_ALeffectState_process,                                                \
  57                                                                               \
  58     T##_ALeffectState_Delete,                                                 \
  59 }
  60
  61
  62 struct ALeffectStateFactoryVtable;
  63
  64 typedef struct ALeffectStateFactory {
  65     const struct ALeffectStateFactoryVtable *vtbl;
  66 } ALeffectStateFactory;
  67
  68 struct ALeffectStateFactoryVtable {
  69     ALeffectState *(*const create)(ALeffectStateFactory *factory);
  70 };
  71
  72 #define DEFINE_ALEFFECTSTATEFACTORY_VTABLE(T)                                 \
  73 DECLARE_THUNK(T, ALeffectStateFactory, ALeffectState*, create)                \
  74                                                                               \
  75 static const struct ALeffectStateFactoryVtable T##_ALeffectStateFactory_vtable = { \
  76     T##_ALeffectStateFactory_create,                                          \
  77 }
  78
  79
  80 #define MAX_EFFECT_CHANNELS (4)
  81
  82
  83 struct ALeffectslotArray {
  84     ALsizei count;
  85     struct ALeffectslot *slot[];
  86 };
  87
  88
  89 struct ALeffectslotProps {
  90     ALfloat   Gain;
  91     ALboolean AuxSendAuto;
  92
  93     ALenum Type;
  94     ALeffectProps Props;
  95
  96     ALeffectState *State;
  97
  98     ATOMIC(struct ALeffectslotProps*) next;
  99 };
 100
 101
 102 typedef struct ALeffectslot {
 103     ALfloat   Gain;
 104     ALboolean AuxSendAuto;
 105
 106     struct {
 107         ALenum Type;
 108         ALeffectProps Props;
 109
 110         ALeffectState *State;
 111     } Effect;
 112
 113     ATOMIC_FLAG PropsClean;
 114
 115     RefCount ref;
 116
 117     ATOMIC(struct ALeffectslotProps*) Update;
 118
 119     struct {
 120         ALfloat   Gain;
 121         ALboolean AuxSendAuto;
 122
 123         ALenum EffectType;
 124         ALeffectProps EffectProps;
 125         ALeffectState *EffectState;
 126
 127         ALfloat RoomRolloff; /* Added to the source's room rolloff, not multiplied. */
 128         ALfloat DecayTime;
 129         ALfloat DecayHFRatio;
 130         ALboolean DecayHFLimit;
 131         ALfloat AirAbsorptionGainHF;
 132     } Params;
 133
 134     /* Self ID */
 135     ALuint id;
 136
 137     ALsizei NumChannels;
 138     BFChannelConfig ChanMap[MAX_EFFECT_CHANNELS];
 139     /* Wet buffer configuration is ACN channel order with N3D scaling:
 140      * * Channel 0 is the unattenuated mono signal.
 141      * * Channel 1 is OpenAL -X
 142      * * Channel 2 is OpenAL Y
 143      * * Channel 3 is OpenAL -Z
 144      * Consequently, effects that only want to work with mono input can use
 145      * channel 0 by itself. Effects that want multichannel can process the
 146      * ambisonics signal and make a B-Format pan (ComputeFirstOrderGains) for
 147      * first-order device output (FOAOut).
 148      */
 149     alignas(16) ALfloat WetBuffer[MAX_EFFECT_CHANNELS][BUFFERSIZE];
 150 } ALeffectslot;
 151
 152 inline void LockEffectSlotsRead(ALCcontext *context)
 153 { LockUIntMapRead(&context->EffectSlotMap); }
 154 inline void UnlockEffectSlotsRead(ALCcontext *context)
 155 { UnlockUIntMapRead(&context->EffectSlotMap); }
 156 inline void LockEffectSlotsWrite(ALCcontext *context)
 157 { LockUIntMapWrite(&context->EffectSlotMap); }
 158 inline void UnlockEffectSlotsWrite(ALCcontext *context)
 159 { UnlockUIntMapWrite(&context->EffectSlotMap); }
 160
 161 inline struct ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id)
 162 { return (struct ALeffectslot*)LookupUIntMapKeyNoLock(&context->EffectSlotMap, id); }
 163 inline struct ALeffectslot *RemoveEffectSlot(ALCcontext *context, ALuint id)
 164 { return (struct ALeffectslot*)RemoveUIntMapKeyNoLock(&context->EffectSlotMap, id); }
 165
 166 ALenum InitEffectSlot(ALeffectslot *slot);
 167 void DeinitEffectSlot(ALeffectslot *slot);
 168 void UpdateEffectSlotProps(ALeffectslot *slot, ALCcontext *context);
 169 void UpdateAllEffectSlotProps(ALCcontext *context);
 170 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);
 171
 172
 173 ALeffectStateFactory *ALnullStateFactory_getFactory(void);
 174 ALeffectStateFactory *ALreverbStateFactory_getFactory(void);
 175 ALeffectStateFactory *ALchorusStateFactory_getFactory(void);
 176 ALeffectStateFactory *ALcompressorStateFactory_getFactory(void);
 177 ALeffectStateFactory *ALdistortionStateFactory_getFactory(void);
 178 ALeffectStateFactory *ALechoStateFactory_getFactory(void);
 179 ALeffectStateFactory *ALequalizerStateFactory_getFactory(void);
 180 ALeffectStateFactory *ALflangerStateFactory_getFactory(void);
 181 ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void);
 182
 183 ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void);
 184
 185
 186 ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
 187
 188 void InitEffectFactoryMap(void);
 189 void DeinitEffectFactoryMap(void);
 190
 191 void ALeffectState_DecRef(ALeffectState *state);
 192
 193 #ifdef __cplusplus
 194 }
 195 #endif
 196
 197 #endif