AuroraOpenALSoft/OpenAL32/Include/alAuxEffectSlot.h

#ifndef _AL_AUXEFFECTSLOT_H_
#define _AL_AUXEFFECTSLOT_H_

#include "AL/al.h"
#include "alEffect.h"
#include "alFilter.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct ALeffectState ALeffectState;

typedef struct ALeffectslot
{
    ALeffect effect;

    ALfloat Gain;
    ALboolean AuxSendAuto;

    ALenum        NeedsUpdate;
    ALeffectState *EffectState;

    ALfloat WetBuffer[BUFFERSIZE];

    ALfloat ClickRemoval[1];
    ALfloat PendingClicks[1];

    ALuint refcount;

    // Index to itself
    ALuint effectslot;

    struct ALeffectslot *next;
} ALeffectslot;


ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);


struct ALeffectState {
    ALvoid (*Destroy)(ALeffectState *State);
    ALboolean (*DeviceUpdate)(ALeffectState *State, ALCdevice *Device);
    ALvoid (*Update)(ALeffectState *State, ALCcontext *Context, const ALeffectslot *Slot);
    ALvoid (*Process)(ALeffectState *State, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[MAXCHANNELS]);
};

ALeffectState *NoneCreate(void);
ALeffectState *EAXVerbCreate(void);
ALeffectState *VerbCreate(void);
ALeffectState *EchoCreate(void);
ALeffectState *ModulatorCreate(void);
ALeffectState *DedicatedDLGCreate(void);
ALeffectState *DedicatedLFECreate(void);

#define ALEffect_Destroy(a)         ((a)->Destroy((a)))
#define ALEffect_DeviceUpdate(a,b)  ((a)->DeviceUpdate((a),(b)))
#define ALEffect_Update(a,b,c)      ((a)->Update((a),(b),(c)))
#define ALEffect_Process(a,b,c,d,e) ((a)->Process((a),(b),(c),(d),(e)))


#ifdef __cplusplus
}
#endif

#endif
Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00			`#ifndef _AL_AUXEFFECTSLOT_H_`
			`#define _AL_AUXEFFECTSLOT_H_`

			`#include "AL/al.h"`
Implement yet another low-pass filter This one using the Butterworth IIR filter design 2008-07-26 02:31:12 +00:00			`#include "alEffect.h"`
			`#include "alFilter.h"`
Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00
			`#ifdef __cplusplus`
			`extern "C" {`
			`#endif`

Don't expose effect-specific structures 2009-05-29 20:30:50 +00:00			`typedef struct ALeffectState ALeffectState;`

Don't append _struct to the effect slot struct name 2008-01-16 00:01:27 +00:00			`typedef struct ALeffectslot`
Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00			`{`
Implement AL_EFFECTSLOT_EFFECT property 2007-12-18 22:22:59 +00:00			`ALeffect effect;`

Implement AL_EFFECTSLOT_GAIN property 2007-12-18 23:47:24 +00:00			`ALfloat Gain;`
Add AL_EFFECTSLOT_AUXILIARY_SEND_AUTO property (still unimplemented) 2007-12-19 01:41:44 +00:00			`ALboolean AuxSendAuto;`
Implement AL_EFFECTSLOT_GAIN property 2007-12-18 23:47:24 +00:00
Use an enum instead of an boolean for some flags They still only hold AL_TRUE or AL_FALSE, but some systems can't properly handle atomic swaps of 1-byte types. 2011-08-29 07:03:09 +00:00			`ALenum NeedsUpdate;`
Don't expose effect-specific structures 2009-05-29 20:30:50 +00:00			`ALeffectState *EffectState;`
Implement AL_EFFECT_REVERB Here is a quick description of how the reverb effect works: +--->---+(4) \| V new sample +-----+---+---+ \| \|extra\|ltr\|ref\| <- +(1) +-----+---+---+ (3,5)\| \|(2) +-->\| V out sample 1) Apply master reverb gain to incoming sample and place it at the head of the buffer. The master reverb gainhf was already applied when the source was initially mixed. 2) Copy the delayed reflection sample to an output sample and apply the reflection gain. 3) Apply the late reverb gain to the late reverb sample 4) Copy the end of the buffer, applying a decay gain and the decay hf ratio, and add to the late reverb. 5) Copy the late reverb sample, adding to the output sample. Then the head and sampling points are shifted forward, and done again for each new sample. The extra buffer length is determined by the Reverb Density property. A value of 0 gives a length of 0.1 seconds (long, with fairly distinct echos) , and 1 gives 0.075 seconds (short, indistinct echos). The decay gain is calculated such that after a number of loops to satisfy the Decay Time, a sample will be 1/32768th as powerful (virtually insignificant to the resulting output, and only getting further reduced). It is calculated as: DecayGain = pow(1.0f/32768.0f, 1.0/(DecayTime/ExtraLength)); Things to note: Reverb Diffusion is not currently handled, nor is Decay HF Limit. Decay HF Ratios above 1 probably give incorrect results. Also, this method likely sucks, but it's the best I can come up with before release. :) 2008-01-19 05:25:40 +00:00
Move the WetBuffer into the effect slot object This should make it easier to support multiple slots 2009-04-12 00:04:55 +00:00			`ALfloat WetBuffer[BUFFERSIZE];`

Add click removal for wet sends 2010-08-15 21:52:12 +00:00			`ALfloat ClickRemoval[1];`
Handle clicks by watching changes between updates 2010-08-16 21:53:21 +00:00			`ALfloat PendingClicks[1];`
Add click removal for wet sends 2010-08-15 21:52:12 +00:00
Keep track of references to effect slots, so they aren't deleted while in use 2008-01-16 21:20:09 +00:00			`ALuint refcount;`

Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00			`// Index to itself`
			`ALuint effectslot;`

Don't append _struct to the effect slot struct name 2008-01-16 00:01:27 +00:00			`struct ALeffectslot *next;`
Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00			`} ALeffectslot;`


Store effect slots in the context 2008-01-16 00:22:39 +00:00			`ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);`
Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00
Don't expose effect-specific structures 2009-05-29 20:30:50 +00:00
			`struct ALeffectState {`
			`ALvoid (Destroy)(ALeffectState State);`
Add a method to update device-dependant effect parameters. The effect state's update method will be called afterwards 2009-10-20 15:31:44 +00:00			`ALboolean (DeviceUpdate)(ALeffectState State, ALCdevice *Device);`
Pass the effect slot to the effect update method 2011-07-16 10:02:16 +00:00			`ALvoid (Update)(ALeffectState State, ALCcontext Context, const ALeffectslot Slot);`
Rename OUTPUTCHANNELS to something more descriptive 2010-12-02 02:33:17 +00:00			`ALvoid (Process)(ALeffectState State, const ALeffectslot Slot, ALuint SamplesToDo, const ALfloat SamplesIn, ALfloat (*SamplesOut)[MAXCHANNELS]);`
Don't expose effect-specific structures 2009-05-29 20:30:50 +00:00			`};`

Handle NULL effect objects as AL_EFFECT_NULL effects 2009-11-06 04:50:56 +00:00			`ALeffectState *NoneCreate(void);`
Be context-agnostic in the effect Create functions This allows the effect Update functions to handle the playback frequency being changed. By default the effects assume a maximum frequency of 192khz, however, it can go higher at the cost of the sample buffers being cleared and the risk of an abort() if reallocation fails 2009-10-19 14:46:53 +00:00			`ALeffectState *EAXVerbCreate(void);`
			`ALeffectState *VerbCreate(void);`
			`ALeffectState *EchoCreate(void);`
Implement a skeleton Ring Modulator effect 2010-04-08 15:54:28 +00:00			`ALeffectState *ModulatorCreate(void);`
Add support for ALC_EXT_DEDICATED 2011-03-13 04:11:25 +00:00			`ALeffectState *DedicatedDLGCreate(void);`
			`ALeffectState *DedicatedLFECreate(void);`
Don't expose effect-specific structures 2009-05-29 20:30:50 +00:00
Apply slot gain on slot output, not input 2009-05-29 23:51:00 +00:00			`#define ALEffect_Destroy(a) ((a)->Destroy((a)))`
Add a method to update device-dependant effect parameters. The effect state's update method will be called afterwards 2009-10-20 15:31:44 +00:00			`#define ALEffect_DeviceUpdate(a,b) ((a)->DeviceUpdate((a),(b)))`
Apply slot gain on slot output, not input 2009-05-29 23:51:00 +00:00			`#define ALEffect_Update(a,b,c) ((a)->Update((a),(b),(c)))`
			`#define ALEffect_Process(a,b,c,d,e) ((a)->Process((a),(b),(c),(d),(e)))`
Don't expose effect-specific structures 2009-05-29 20:30:50 +00:00

Add auxiliary effect slot function skeletons 2007-12-18 01:43:19 +00:00			`#ifdef __cplusplus`
			`}`
			`#endif`

			`#endif`