#include "config.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include "alMain.h"
#include "alSource.h"
#include "alBuffer.h"
#include "alListener.h"
#include "alAuxEffectSlot.h"
#include "alu.h"
#include "bs2b.h"
#include "mixer_defs.h"

Macros
#define	DECL_TEMPLATE(T, func)

Functions
static __inline void	aluCrossproduct (const ALfloat inVector1, const ALfloat inVector2, ALfloat *outVector)

static __inline ALfloat	aluDotproduct (const ALfloat inVector1, const ALfloat inVector2)

static __inline ALbyte	aluF2B (ALfloat val)

static __inline ALfloat	aluF2F (ALfloat val)

static __inline ALint	aluF2I (ALfloat val)

static __inline ALshort	aluF2S (ALfloat val)

static __inline ALubyte	aluF2UB (ALfloat val)

static __inline ALuint	aluF2UI (ALfloat val)

static __inline ALushort	aluF2US (ALfloat val)

ALvoid	aluHandleDisconnect (ALCdevice *device)

static __inline ALvoid	aluMatrixVector (ALfloat vector, ALfloat w, ALfloat(RESTRICT matrix)[4])

ALvoid	aluMixData (ALCdevice device, ALvoid buffer, ALsizei size)

static __inline void	aluNormalize (ALfloat *inVector)

static ALvoid	CalcListenerParams (ALlistener *Listener)

ALvoid	CalcNonAttnSourceParams (ALsource ALSource, const ALCcontext ALContext)

ALvoid	CalcSourceParams (ALsource ALSource, const ALCcontext ALContext)

static DryMixerFunc	SelectDirectMixer (void)

static DryMixerFunc	SelectHrtfMixer (void)

static ResamplerFunc	SelectResampler (enum Resampler Resampler, ALuint increment)

static WetMixerFunc	SelectSendMixer (void)

Variables
ALfloat	ConeScale = 1.0f

ALfloat	ZScale = 1.0f

Macro Definition Documentation

#define DECL_TEMPLATE	(	T,
		func
	)

Value:

static int Write_##T(ALCdevice *device, T *RESTRICT buffer,                   \
                     ALuint SamplesToDo)                                      \
{                                                                             \
    ALfloat (*RESTRICT DryBuffer)[BUFFERSIZE] = device->DryBuffer;            \
    ALuint numchans = ChannelsFromDevFmt(device->FmtChans);                   \
    const ALuint *offsets = device->ChannelOffsets;                           \
    ALuint i, j;                                                              \
                                                                              \
    for(j = 0;j < MaxChannels;j++)                                            \
    {                                                                         \
        T *RESTRICT out;                                                      \
                                                                              \
        if(offsets[j] == INVALID_OFFSET)                                      \
            continue;                                                         \
                                                                              \
        out = buffer + offsets[j];                                            \
        for(i = 0;i < SamplesToDo;i++)                                        \
            out[i*numchans] = func(DryBuffer[j][i]);                          \
    }                                                                         \
    return SamplesToDo*numchans*sizeof(T);                                    \
}