OpenAL32/Include/alu.h

   1 #ifndef _ALU_H_
   2 #define _ALU_H_
   3
   4 #include "AL/al.h"
   5 #include "AL/alc.h"
   6 #include "AL/alext.h"
   7
   8 #include <limits.h>
   9 #include <math.h>
  10 #ifdef HAVE_FLOAT_H
  11 #include <float.h>
  12 /* HACK: Seems cross-compiling with MinGW includes the wrong float.h, which
  13  * doesn't define Windows' _controlfp and related macros */
  14 #if defined(__MINGW32__) && !defined(_RC_CHOP)
  15 /* Control word masks for unMask */
  16 #define _MCW_EM         0x0008001F      /* Error masks */
  17 #define _MCW_IC         0x00040000      /* Infinity */
  18 #define _MCW_RC         0x00000300      /* Rounding */
  19 #define _MCW_PC         0x00030000      /* Precision */
  20 /* Control word values for unNew (use with related unMask above) */
  21 #define _EM_INVALID     0x00000010
  22 #define _EM_DENORMAL    0x00080000
  23 #define _EM_ZERODIVIDE  0x00000008
  24 #define _EM_OVERFLOW    0x00000004
  25 #define _EM_UNDERFLOW   0x00000002
  26 #define _EM_INEXACT     0x00000001
  27 #define _IC_AFFINE      0x00040000
  28 #define _IC_PROJECTIVE  0x00000000
  29 #define _RC_CHOP        0x00000300
  30 #define _RC_UP          0x00000200
  31 #define _RC_DOWN        0x00000100
  32 #define _RC_NEAR        0x00000000
  33 #define _PC_24          0x00020000
  34 #define _PC_53          0x00010000
  35 #define _PC_64          0x00000000
  36 _CRTIMP unsigned int __cdecl __MINGW_NOTHROW _controlfp (unsigned int unNew, unsigned int unMask);
  37 #endif
  38 #endif
  39 #ifdef HAVE_IEEEFP_H
  40 #include <ieeefp.h>
  41 #endif
  42
  43
  44 #define F_PI    (3.14159265358979323846f)  /* pi */
  45 #define F_PI_2  (1.57079632679489661923f)  /* pi/2 */
  46
  47 #ifndef HAVE_POWF
  48 static __inline float powf(float x, float y)
  49 { return (float)pow(x, y); }
  50 #endif
  51
  52 #ifndef HAVE_SQRTF
  53 static __inline float sqrtf(float x)
  54 { (float)sqrt(x); }
  55 #endif
  56
  57 #ifndef HAVE_COSF
  58 static __inline float cosf(float x)
  59 { (float)cos(x); }
  60 #endif
  61
  62 #ifndef HAVE_SINF
  63 static __inline float sinf(float x)
  64 { (float)sin(x); }
  65 #endif
  66
  67 #ifndef HAVE_ACOSF
  68 static __inline float acosf(float x)
  69 { (float)acos(x); }
  70 #endif
  71
  72 #ifndef HAVE_ASINF
  73 static __inline float asinf(float x)
  74 { (float)asin(x); }
  75 #endif
  76
  77 #ifndef HAVE_ATANF
  78 static __inline float atanf(float x)
  79 { (float)atan(x); }
  80 #endif
  81
  82 #ifndef HAVE_ATAN2F
  83 static __inline float atan2f(float x, float y)
  84 { (float)atan2(x, y); }
  85 #endif
  86
  87 #ifndef HAVE_FABSF
  88 static __inline float fabsf(float x)
  89 { (float)fabs(x); }
  90 #endif
  91
  92 #ifndef HAVE_LOG10F
  93 static __inline float log10f(float x)
  94 { (float)log10(x); }
  95 #endif
  96
  97 #ifndef HAVE_FLOORF
  98 static __inline float floorf(float x)
  99 { (float)floor(x); }
 100 #endif
 101
 102 #ifdef __cplusplus
 103 extern "C" {
 104 #endif
 105
 106 struct ALsource;
 107 struct ALbuffer;
 108 struct DirectParams;
 109 struct SendParams;
 110
 111 typedef ALvoid (*DryMixerFunc)(struct ALsource *self, ALCdevice *Device,
 112                                struct DirectParams *params,
 113                                const ALfloat *RESTRICT data, ALuint srcfrac,
 114                                ALuint OutPos, ALuint SamplesToDo,
 115                                ALuint BufferSize);
 116 typedef ALvoid (*WetMixerFunc)(struct ALsource *self, ALuint sendidx,
 117                                struct SendParams *params,
 118                                const ALfloat *RESTRICT data, ALuint srcfrac,
 119                                ALuint OutPos, ALuint SamplesToDo,
 120                                ALuint BufferSize);
 121
 122 enum Resampler {
 123     PointResampler,
 124     LinearResampler,
 125     CubicResampler,
 126
 127     ResamplerMax,
 128 };
 129
 130 enum Channel {
 131     FrontLeft = 0,
 132     FrontRight,  /* 1 */
 133     FrontCenter, /* 2 */
 134     LFE,         /* 3 */
 135     BackLeft,    /* 4 */
 136     BackRight,   /* 5 */
 137     BackCenter,  /* 6 */
 138     SideLeft,    /* 7 */
 139     SideRight,   /* 8 */
 140
 141     /* Must be a multiple of 4 */
 142     MaxChannels = 12,
 143 };
 144
 145 enum DistanceModel {
 146     InverseDistanceClamped  = AL_INVERSE_DISTANCE_CLAMPED,
 147     LinearDistanceClamped   = AL_LINEAR_DISTANCE_CLAMPED,
 148     ExponentDistanceClamped = AL_EXPONENT_DISTANCE_CLAMPED,
 149     InverseDistance  = AL_INVERSE_DISTANCE,
 150     LinearDistance   = AL_LINEAR_DISTANCE,
 151     ExponentDistance = AL_EXPONENT_DISTANCE,
 152     DisableDistance  = AL_NONE,
 153
 154     DefaultDistanceModel = InverseDistanceClamped
 155 };
 156
 157 #define BUFFERSIZE 4096
 158
 159 #define FRACTIONBITS (14)
 160 #define FRACTIONONE  (1<<FRACTIONBITS)
 161 #define FRACTIONMASK (FRACTIONONE-1)
 162
 163 /* Size for temporary stack storage of buffer data. Must be a multiple of the
 164  * size of ALfloat, ie, 4. Larger values need more stack, while smaller values
 165  * may need more iterations. The value needs to be a sensible size, however, as
 166  * it constrains the max stepping value used for mixing.
 167  * The mixer requires being able to do two samplings per mixing loop. A 16KB
 168  * buffer can hold 512 sample frames for a 7.1 float buffer. With the cubic
 169  * resampler (which requires 3 padding sample frames), this limits the maximum
 170  * step to about 508. This means that buffer_freq*source_pitch cannot exceed
 171  * device_freq*508 for an 8-channel 32-bit buffer. */
 172 #ifndef STACK_DATA_SIZE
 173 #define STACK_DATA_SIZE  16384
 174 #endif
 175
 176
 177 static __inline ALfloat minf(ALfloat a, ALfloat b)
 178 { return ((a > b) ? b : a); }
 179 static __inline ALfloat maxf(ALfloat a, ALfloat b)
 180 { return ((a > b) ? a : b); }
 181 static __inline ALfloat clampf(ALfloat val, ALfloat min, ALfloat max)
 182 { return minf(max, maxf(min, val)); }
 183
 184 static __inline ALuint minu(ALuint a, ALuint b)
 185 { return ((a > b) ? b : a); }
 186 static __inline ALuint maxu(ALuint a, ALuint b)
 187 { return ((a > b) ? a : b); }
 188 static __inline ALuint clampu(ALuint val, ALuint min, ALuint max)
 189 { return minu(max, maxu(min, val)); }
 190
 191 static __inline ALint mini(ALint a, ALint b)
 192 { return ((a > b) ? b : a); }
 193 static __inline ALint maxi(ALint a, ALint b)
 194 { return ((a > b) ? a : b); }
 195 static __inline ALint clampi(ALint val, ALint min, ALint max)
 196 { return mini(max, maxi(min, val)); }
 197
 198 static __inline ALint64 mini64(ALint64 a, ALint64 b)
 199 { return ((a > b) ? b : a); }
 200 static __inline ALint64 maxi64(ALint64 a, ALint64 b)
 201 { return ((a > b) ? a : b); }
 202 static __inline ALint64 clampi64(ALint64 val, ALint64 min, ALint64 max)
 203 { return mini64(max, maxi64(min, val)); }
 204
 205 static __inline ALuint64 minu64(ALuint64 a, ALuint64 b)
 206 { return ((a > b) ? b : a); }
 207 static __inline ALuint64 maxu64(ALuint64 a, ALuint64 b)
 208 { return ((a > b) ? a : b); }
 209 static __inline ALuint64 clampu64(ALuint64 val, ALuint64 min, ALuint64 max)
 210 { return minu64(max, maxu64(min, val)); }
 211
 212
 213 static __inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu)
 214 {
 215     return val1 + (val2-val1)*mu;
 216 }
 217 static __inline ALfloat cubic(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALfloat mu)
 218 {
 219     ALfloat mu2 = mu*mu;
 220     ALfloat a0 = -0.5f*val0 +  1.5f*val1 + -1.5f*val2 +  0.5f*val3;
 221     ALfloat a1 =       val0 + -2.5f*val1 +  2.0f*val2 + -0.5f*val3;
 222     ALfloat a2 = -0.5f*val0              +  0.5f*val2;
 223     ALfloat a3 =                    val1;
 224
 225     return a0*mu*mu2 + a1*mu2 + a2*mu + a3;
 226 }
 227
 228
 229 static __inline int SetMixerFPUMode(void)
 230 {
 231 #if defined(_FPU_GETCW) && defined(_FPU_SETCW) && (defined(__i386__) || defined(__x86_64__))
 232     fpu_control_t fpuState, newState;
 233     _FPU_GETCW(fpuState);
 234     newState = fpuState&~(_FPU_EXTENDED|_FPU_DOUBLE|_FPU_SINGLE |
 235                           _FPU_RC_NEAREST|_FPU_RC_DOWN|_FPU_RC_UP|_FPU_RC_ZERO);
 236     newState |= _FPU_SINGLE | _FPU_RC_ZERO;
 237     _FPU_SETCW(newState);
 238 #else
 239     int fpuState;
 240 #if defined(HAVE__CONTROLFP)
 241     fpuState = _controlfp(0, 0);
 242     (void)_controlfp(_RC_CHOP|_PC_24, _MCW_RC|_MCW_PC);
 243 #elif defined(HAVE_FESETROUND)
 244     fpuState = fegetround();
 245 #ifdef FE_TOWARDZERO
 246     fesetround(FE_TOWARDZERO);
 247 #endif
 248 #endif
 249 #endif
 250     return fpuState;
 251 }
 252
 253 static __inline void RestoreFPUMode(int state)
 254 {
 255 #if defined(_FPU_GETCW) && defined(_FPU_SETCW) && (defined(__i386__) || defined(__x86_64__))
 256     fpu_control_t fpuState = state;
 257     _FPU_SETCW(fpuState);
 258 #elif defined(HAVE__CONTROLFP)
 259     _controlfp(state, _MCW_RC|_MCW_PC);
 260 #elif defined(HAVE_FESETROUND)
 261     fesetround(state);
 262 #endif
 263 }
 264
 265
 266 static __inline void aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
 267 {
 268     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
 269     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
 270     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
 271 }
 272
 273 static __inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)
 274 {
 275     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
 276            inVector1[2]*inVector2[2];
 277 }
 278
 279 static __inline void aluNormalize(ALfloat *inVector)
 280 {
 281     ALfloat lengthsqr = aluDotproduct(inVector, inVector);
 282     if(lengthsqr > 0.0f)
 283     {
 284         ALfloat inv_length = 1.0f/sqrtf(lengthsqr);
 285         inVector[0] *= inv_length;
 286         inVector[1] *= inv_length;
 287         inVector[2] *= inv_length;
 288     }
 289 }
 290
 291
 292 ALvoid aluInitPanning(ALCdevice *Device);
 293
 294 ALvoid ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat *gains);
 295
 296 ALvoid CalcSourceParams(struct ALsource *ALSource, const ALCcontext *ALContext);
 297 ALvoid CalcNonAttnSourceParams(struct ALsource *ALSource, const ALCcontext *ALContext);
 298
 299 DryMixerFunc SelectDirectMixer(enum Resampler Resampler);
 300 DryMixerFunc SelectHrtfMixer(enum Resampler Resampler);
 301 WetMixerFunc SelectSendMixer(enum Resampler Resampler);
 302
 303 ALvoid MixSource(struct ALsource *Source, ALCdevice *Device, ALuint SamplesToDo);
 304
 305 ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size);
 306 ALvoid aluHandleDisconnect(ALCdevice *device);
 307
 308 extern ALfloat ConeScale;
 309 extern ALfloat ZScale;
 310
 311 #ifdef __cplusplus
 312 }
 313 #endif
 314
 315 #endif
 316