rlm@0: #ifndef _ALU_H_
rlm@0: #define _ALU_H_
rlm@0: 
rlm@0: #include "AL/al.h"
rlm@0: #include "AL/alc.h"
rlm@0: #include "AL/alext.h"
rlm@0: 
rlm@0: #include <limits.h>
rlm@0: #include <math.h>
rlm@0: #ifdef HAVE_FLOAT_H
rlm@0: #include <float.h>
rlm@0: #endif
rlm@0: #ifdef HAVE_IEEEFP_H
rlm@0: #include <ieeefp.h>
rlm@0: #endif
rlm@0: 
rlm@0: #ifndef M_PI
rlm@0: #define M_PI           3.14159265358979323846  /* pi */
rlm@0: #define M_PI_2         1.57079632679489661923  /* pi/2 */
rlm@0: #endif
rlm@0: 
rlm@0: #ifdef HAVE_POWF
rlm@0: #define aluPow(x,y) (powf((x),(y)))
rlm@0: #else
rlm@0: #define aluPow(x,y) ((ALfloat)pow((double)(x),(double)(y)))
rlm@0: #endif
rlm@0: 
rlm@0: #ifdef HAVE_SQRTF
rlm@0: #define aluSqrt(x) (sqrtf((x)))
rlm@0: #else
rlm@0: #define aluSqrt(x) ((ALfloat)sqrt((double)(x)))
rlm@0: #endif
rlm@0: 
rlm@0: #ifdef HAVE_ACOSF
rlm@0: #define aluAcos(x) (acosf((x)))
rlm@0: #else
rlm@0: #define aluAcos(x) ((ALfloat)acos((double)(x)))
rlm@0: #endif
rlm@0: 
rlm@0: #ifdef HAVE_ATANF
rlm@0: #define aluAtan(x) (atanf((x)))
rlm@0: #else
rlm@0: #define aluAtan(x) ((ALfloat)atan((double)(x)))
rlm@0: #endif
rlm@0: 
rlm@0: #ifdef HAVE_FABSF
rlm@0: #define aluFabs(x) (fabsf((x)))
rlm@0: #else
rlm@0: #define aluFabs(x) ((ALfloat)fabs((double)(x)))
rlm@0: #endif
rlm@0: 
rlm@0: #define QUADRANT_NUM  128
rlm@0: #define LUT_NUM       (4 * QUADRANT_NUM)
rlm@0: 
rlm@0: #ifdef __cplusplus
rlm@0: extern "C" {
rlm@0: #endif
rlm@0: 
rlm@0: struct ALsource;
rlm@0: struct ALbuffer;
rlm@0: 
rlm@0: typedef ALvoid (*MixerFunc)(struct ALsource *self, ALCdevice *Device,
rlm@0:                             const ALvoid *RESTRICT data,
rlm@0:                             ALuint *DataPosInt, ALuint *DataPosFrac,
rlm@0:                             ALuint OutPos, ALuint SamplesToDo,
rlm@0:                             ALuint BufferSize);
rlm@0: 
rlm@0: enum Resampler {
rlm@0:     POINT_RESAMPLER = 0,
rlm@0:     LINEAR_RESAMPLER,
rlm@0:     CUBIC_RESAMPLER,
rlm@0: 
rlm@0:     RESAMPLER_MAX,
rlm@0:     RESAMPLER_MIN = -1,
rlm@0:     RESAMPLER_DEFAULT = LINEAR_RESAMPLER
rlm@0: };
rlm@0: 
rlm@0: enum Channel {
rlm@0:     FRONT_LEFT = 0,
rlm@0:     FRONT_RIGHT,
rlm@0:     FRONT_CENTER,
rlm@0:     LFE,
rlm@0:     BACK_LEFT,
rlm@0:     BACK_RIGHT,
rlm@0:     BACK_CENTER,
rlm@0:     SIDE_LEFT,
rlm@0:     SIDE_RIGHT,
rlm@0: 
rlm@0:     MAXCHANNELS
rlm@0: };
rlm@0: 
rlm@0: enum DistanceModel {
rlm@0:     InverseDistanceClamped  = AL_INVERSE_DISTANCE_CLAMPED,
rlm@0:     LinearDistanceClamped   = AL_LINEAR_DISTANCE_CLAMPED,
rlm@0:     ExponentDistanceClamped = AL_EXPONENT_DISTANCE_CLAMPED,
rlm@0:     InverseDistance  = AL_INVERSE_DISTANCE,
rlm@0:     LinearDistance   = AL_LINEAR_DISTANCE,
rlm@0:     ExponentDistance = AL_EXPONENT_DISTANCE,
rlm@0:     DisableDistance  = AL_NONE
rlm@0: };
rlm@0: 
rlm@0: #define BUFFERSIZE 4096
rlm@0: 
rlm@0: #define FRACTIONBITS (14)
rlm@0: #define FRACTIONONE  (1<<FRACTIONBITS)
rlm@0: #define FRACTIONMASK (FRACTIONONE-1)
rlm@0: 
rlm@0: /* Size for temporary stack storage of buffer data. Larger values need more
rlm@0:  * stack, while smaller values may need more iterations. The value needs to be
rlm@0:  * a sensible size, however, as it constrains the max stepping value used for
rlm@0:  * mixing.
rlm@0:  * The mixer requires being able to do two samplings per mixing loop. A 16KB
rlm@0:  * buffer can hold 512 sample frames for a 7.1 float buffer. With the cubic
rlm@0:  * resampler (which requires 3 padding sample frames), this limits the maximum
rlm@0:  * step to about 508. This means that buffer_freq*source_pitch cannot exceed
rlm@0:  * device_freq*508 for an 8-channel 32-bit buffer. */
rlm@0: #ifndef STACK_DATA_SIZE
rlm@0: #define STACK_DATA_SIZE  16384
rlm@0: #endif
rlm@0: 
rlm@0: 
rlm@0: static __inline ALfloat minf(ALfloat a, ALfloat b)
rlm@0: { return ((a > b) ? b : a); }
rlm@0: static __inline ALfloat maxf(ALfloat a, ALfloat b)
rlm@0: { return ((a > b) ? a : b); }
rlm@0: static __inline ALfloat clampf(ALfloat val, ALfloat min, ALfloat max)
rlm@0: { return minf(max, maxf(min, val)); }
rlm@0: 
rlm@0: static __inline ALuint minu(ALuint a, ALuint b)
rlm@0: { return ((a > b) ? b : a); }
rlm@0: static __inline ALuint maxu(ALuint a, ALuint b)
rlm@0: { return ((a > b) ? a : b); }
rlm@0: static __inline ALuint clampu(ALuint val, ALuint min, ALuint max)
rlm@0: { return minu(max, maxu(min, val)); }
rlm@0: 
rlm@0: static __inline ALint mini(ALint a, ALint b)
rlm@0: { return ((a > b) ? b : a); }
rlm@0: static __inline ALint maxi(ALint a, ALint b)
rlm@0: { return ((a > b) ? a : b); }
rlm@0: static __inline ALint clampi(ALint val, ALint min, ALint max)
rlm@0: { return mini(max, maxi(min, val)); }
rlm@0: 
rlm@0: 
rlm@0: static __inline ALdouble lerp(ALdouble val1, ALdouble val2, ALdouble mu)
rlm@0: {
rlm@0:     return val1 + (val2-val1)*mu;
rlm@0: }
rlm@0: static __inline ALdouble cubic(ALdouble val0, ALdouble val1, ALdouble val2, ALdouble val3, ALdouble mu)
rlm@0: {
rlm@0:     ALdouble mu2 = mu*mu;
rlm@0:     ALdouble a0 = -0.5*val0 +  1.5*val1 + -1.5*val2 +  0.5*val3;
rlm@0:     ALdouble a1 =      val0 + -2.5*val1 +  2.0*val2 + -0.5*val3;
rlm@0:     ALdouble a2 = -0.5*val0             +  0.5*val2;
rlm@0:     ALdouble a3 =                  val1;
rlm@0: 
rlm@0:     return a0*mu*mu2 + a1*mu2 + a2*mu + a3;
rlm@0: }
rlm@0: 
rlm@0: ALvoid aluInitPanning(ALCdevice *Device);
rlm@0: ALint aluCart2LUTpos(ALfloat re, ALfloat im);
rlm@0: 
rlm@0: ALvoid CalcSourceParams(struct ALsource *ALSource, const ALCcontext *ALContext);
rlm@0: ALvoid CalcNonAttnSourceParams(struct ALsource *ALSource, const ALCcontext *ALContext);
rlm@0: 
rlm@0: MixerFunc SelectMixer(struct ALbuffer *Buffer, enum Resampler Resampler);
rlm@0: MixerFunc SelectHrtfMixer(struct ALbuffer *Buffer, enum Resampler Resampler);
rlm@0: 
rlm@0: ALvoid MixSource(struct ALsource *Source, ALCdevice *Device, ALuint SamplesToDo);
rlm@0: 
rlm@0: ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size);
rlm@0: ALvoid aluHandleDisconnect(ALCdevice *device);
rlm@0: 
rlm@0: #ifdef __cplusplus
rlm@0: }
rlm@0: #endif
rlm@0: 
rlm@0: #endif
rlm@0: