OpenAL32/Include/alMain.h

   1 #ifndef AL_MAIN_H
   2 #define AL_MAIN_H
   3
   4 #include <string.h>
   5 #include <stdio.h>
   6 #include <stdarg.h>
   7 #include <assert.h>
   8 #include <math.h>
   9
  10 #ifdef HAVE_STRINGS_H
  11 #include <strings.h>
  12 #endif
  13
  14 #ifdef HAVE_FENV_H
  15 #include <fenv.h>
  16 #endif
  17
  18 #include "AL/al.h"
  19 #include "AL/alc.h"
  20 #include "AL/alext.h"
  21
  22 #include "atomic.h"
  23 #include "uintmap.h"
  24
  25 #ifndef ALC_SOFT_HRTF
  26 #define ALC_SOFT_HRTF 1
  27 #define ALC_HRTF_SOFT                            0x1992
  28 #endif
  29
  30 #ifndef ALC_SOFT_midi_interface
  31 #define ALC_SOFT_midi_interface 1
  32 #define AL_MIDI_CLOCK_SOFT                       0x9999
  33 #define AL_MIDI_STATE_SOFT                       0x9986
  34 #define AL_MIDI_GAIN_SOFT                        0x9998
  35 #define AL_MIDI_PRESET_SOFT                      0x9997
  36 #define AL_MIDI_BANK_SOFT                        0x9996
  37 #define AL_SOUNDFONTS_SIZE_SOFT                  0x9995
  38 #define AL_SOUNDFONTS_SOFT                       0x9994
  39 #define AL_PRESETS_SIZE_SOFT                     0x9993
  40 #define AL_PRESETS_SOFT                          0x9992
  41 #define AL_FONTSOUNDS_SIZE_SOFT                  0x9991
  42 #define AL_FONTSOUNDS_SOFT                       0x9990
  43
  44 #define AL_SOURCE0_INPUT_SOFT                    0x998F
  45 #define AL_SOURCE0_TYPE_SOFT                     0x998E
  46 #define AL_SOURCE0_FORM_SOFT                     0x998D
  47 #define AL_SOURCE1_INPUT_SOFT                    0x998C
  48 #define AL_SOURCE1_TYPE_SOFT                     0x998B
  49 #define AL_SOURCE1_FORM_SOFT                     0x998A
  50 #define AL_AMOUNT_SOFT                           0x9989
  51 #define AL_TRANSFORM_OP_SOFT                     0x9988
  52 #define AL_DESTINATION_SOFT                      0x9987
  53
  54 /* Sounce Input */
  55 #define AL_ONE_SOFT                              0x0080
  56 #define AL_NOTEON_VELOCITY_SOFT                  0x0082
  57 #define AL_NOTEON_KEY_SOFT                       0x0083
  58 /* aftertouch */
  59 /* channelpressure */
  60 /* pitchbend */
  61 #define AL_PITCHBEND_SENSITIVITY_SOFT            0x0090
  62 /* 0...127 CC */
  63
  64 /* Source Type */
  65 #define AL_UNORM_SOFT                            0x0000
  66 #define AL_UNORM_REV_SOFT                        0x0100
  67 #define AL_SNORM_SOFT                            0x0200
  68 #define AL_SNORM_REV_SOFT                        0x0300
  69
  70 /* Source Form */
  71 #define AL_LINEAR_SOFT                           0x0000
  72 #define AL_CONCAVE_SOFT                          0x0400
  73 #define AL_CONVEX_SOFT                           0x0800
  74 #define AL_SWITCH_SOFT                           0x0C00
  75
  76 /* Transform op */
  77 /* linear */
  78 #define AL_ABSOLUTE_SOFT                         0x0002
  79
  80 #define AL_SAMPLE_START_SOFT                     0x2000
  81 #define AL_SAMPLE_END_SOFT                       0x2001
  82 #define AL_SAMPLE_LOOP_START_SOFT                0x2002
  83 #define AL_SAMPLE_LOOP_END_SOFT                  0x2003
  84 #define AL_SAMPLE_RATE_SOFT                      0x2004
  85 #define AL_BASE_KEY_SOFT                         0x2005
  86 #define AL_KEY_CORRECTION_SOFT                   0x2006
  87 #define AL_SAMPLE_TYPE_SOFT                      0x2007
  88 #define AL_FONTSOUND_LINK_SOFT                   0x2008
  89 #define AL_MOD_LFO_TO_PITCH_SOFT                 0x0005
  90 #define AL_VIBRATO_LFO_TO_PITCH_SOFT             0x0006
  91 #define AL_MOD_ENV_TO_PITCH_SOFT                 0x0007
  92 #define AL_FILTER_CUTOFF_SOFT                    0x0008
  93 #define AL_FILTER_RESONANCE_SOFT                 0x0009
  94 #define AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT         0x000A
  95 #define AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT         0x000B
  96 #define AL_MOD_LFO_TO_VOLUME_SOFT                0x000D
  97 #define AL_CHORUS_SEND_SOFT                      0x000F
  98 #define AL_REVERB_SEND_SOFT                      0x0010
  99 #define AL_PAN_SOFT                              0x0011
 100 #define AL_MOD_LFO_DELAY_SOFT                    0x0015
 101 #define AL_MOD_LFO_FREQUENCY_SOFT                0x0016
 102 #define AL_VIBRATO_LFO_DELAY_SOFT                0x0017
 103 #define AL_VIBRATO_LFO_FREQUENCY_SOFT            0x0018
 104 #define AL_MOD_ENV_DELAYTIME_SOFT                0x0019
 105 #define AL_MOD_ENV_ATTACKTIME_SOFT               0x001A
 106 #define AL_MOD_ENV_HOLDTIME_SOFT                 0x001B
 107 #define AL_MOD_ENV_DECAYTIME_SOFT                0x001C
 108 #define AL_MOD_ENV_SUSTAINVOLUME_SOFT            0x001D
 109 #define AL_MOD_ENV_RELEASETIME_SOFT              0x002E
 110 #define AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT          0x001F
 111 #define AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT         0x0020
 112 #define AL_VOLUME_ENV_DELAYTIME_SOFT             0x0021
 113 #define AL_VOLUME_ENV_ATTACKTIME_SOFT            0x0022
 114 #define AL_VOLUME_ENV_HOLDTIME_SOFT              0x0023
 115 #define AL_VOLUME_ENV_DECAYTIME_SOFT             0x0024
 116 #define AL_VOLUME_ENV_SUSTAINVOLUME_SOFT         0x0025
 117 #define AL_VOLUME_ENV_RELEASETIME_SOFT           0x0026
 118 #define AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT       0x0027
 119 #define AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT      0x0028
 120 #define AL_KEY_RANGE_SOFT                        0x002B
 121 #define AL_VELOCITY_RANGE_SOFT                   0x002C
 122 #define AL_ATTENUATION_SOFT                      0x0030
 123 #define AL_TUNING_COARSE_SOFT                    0x0033
 124 #define AL_TUNING_FINE_SOFT                      0x0034
 125 #define AL_LOOP_MODE_SOFT                        0x0036
 126 #define AL_TUNING_SCALE_SOFT                     0x0038
 127 #define AL_EXCLUSIVE_CLASS_SOFT                  0x0039
 128 #define AL_LOOP_CONTINUOUS_SOFT                  0x0001
 129 #define AL_LOOP_UNTIL_RELEASE_SOFT               0x0003
 130 #define AL_RIGHT_SOFT                            0x0002
 131 #define AL_LEFT_SOFT                             0x0004
 132 #define AL_FORMAT_TYPE_SOFT                      0x1991
 133 #define AL_NOTEOFF_SOFT                          0x0080
 134 #define AL_NOTEON_SOFT                           0x0090
 135 #define AL_AFTERTOUCH_SOFT                       0x00A0
 136 #define AL_CONTROLLERCHANGE_SOFT                 0x00B0
 137 #define AL_PROGRAMCHANGE_SOFT                    0x00C0
 138 #define AL_CHANNELPRESSURE_SOFT                  0x00D0
 139 #define AL_PITCHBEND_SOFT                        0x00E0
 140 typedef void (AL_APIENTRY*LPALGENSOUNDFONTSSOFT)(ALsizei n, ALuint *ids);
 141 typedef void (AL_APIENTRY*LPALDELETESOUNDFONTSSOFT)(ALsizei n, const ALuint *ids);
 142 typedef ALboolean (AL_APIENTRY*LPALISSOUNDFONTSOFT)(ALuint id);
 143 typedef void (AL_APIENTRY*LPALSOUNDFONTSAMPLESSOFT)(ALuint sfid, ALenum type, ALsizei count, const ALvoid *samples);
 144 typedef void (AL_APIENTRY*LPALGETSOUNDFONTSAMPLESSOFT)(ALuint id, ALsizei offset, ALsizei count, ALenum type, ALvoid *samples);
 145 typedef ALvoid* (AL_APIENTRY*LPALSOUNDFONTMAPSAMPLESSOFT)(ALuint sfid, ALsizei offset, ALsizei length);
 146 typedef void (AL_APIENTRY*LPALSOUNDFONTUNMAPSAMPLESSOFT)(ALuint sfid);
 147 typedef void (AL_APIENTRY*LPALGETSOUNDFONTIVSOFT)(ALuint id, ALenum param, ALint *values);
 148 typedef void (AL_APIENTRY*LPALSOUNDFONTPRESETSSOFT)(ALuint id, ALsizei count, const ALuint *pids);
 149 typedef void (AL_APIENTRY*LPALGENPRESETSSOFT)(ALsizei n, ALuint *ids);
 150 typedef void (AL_APIENTRY*LPALDELETEPRESETSSOFT)(ALsizei n, const ALuint *ids);
 151 typedef ALboolean (AL_APIENTRY*LPALISPRESETSOFT)(ALuint id);
 152 typedef void (AL_APIENTRY*LPALPRESETISOFT)(ALuint id, ALenum param, ALint value);
 153 typedef void (AL_APIENTRY*LPALPRESETIVSOFT)(ALuint id, ALenum param, const ALint *values);
 154 typedef void (AL_APIENTRY*LPALPRESETFONTSOUNDSSOFT)(ALuint id, ALsizei count, const ALuint *fsids);
 155 typedef void (AL_APIENTRY*LPALGETPRESETIVSOFT)(ALuint id, ALenum param, ALint *values);
 156 typedef void (AL_APIENTRY*LPALGENFONTSOUNDSSOFT)(ALsizei n, ALuint *ids);
 157 typedef void (AL_APIENTRY*LPALDELETEFONTSOUNDSSOFT)(ALsizei n, const ALuint *ids);
 158 typedef ALboolean (AL_APIENTRY*LPALISFONTSOUNDSOFT)(ALuint id);
 159 typedef void (AL_APIENTRY*LPALFONTSOUNDISOFT)(ALuint id, ALenum param, ALint value);
 160 typedef void (AL_APIENTRY*LPALFONTSOUND2ISOFT)(ALuint id, ALenum param, ALint value1, ALint value2);
 161 typedef void (AL_APIENTRY*LPALFONTSOUNDIVSOFT)(ALuint id, ALenum param, const ALint *values);
 162 typedef void (AL_APIENTRY*LPALGETFONTSOUNDIVSOFT)(ALuint id, ALenum param, ALint *values);
 163 typedef void (AL_APIENTRY*LPALFONTSOUNDMOFULATORISOFT)(ALuint id, ALsizei stage, ALenum param, ALint value);
 164 typedef void (AL_APIENTRY*LPALGETFONTSOUNDMODULATORIVSOFT)(ALuint id, ALsizei stage, ALenum param, ALint *values);
 165 typedef void (AL_APIENTRY*LPALMIDISOUNDFONTSOFT)(ALuint id);
 166 typedef void (AL_APIENTRY*LPALMIDISOUNDFONTVSOFT)(ALsizei count, const ALuint *ids);
 167 typedef void (AL_APIENTRY*LPALMIDIEVENTSOFT)(ALuint64SOFT time, ALenum event, ALsizei channel, ALsizei param1, ALsizei param2);
 168 typedef void (AL_APIENTRY*LPALMIDISYSEXSOFT)(ALuint64SOFT time, const ALbyte *data, ALsizei size);
 169 typedef void (AL_APIENTRY*LPALMIDIPLAYSOFT)(void);
 170 typedef void (AL_APIENTRY*LPALMIDIPAUSESOFT)(void);
 171 typedef void (AL_APIENTRY*LPALMIDISTOPSOFT)(void);
 172 typedef void (AL_APIENTRY*LPALMIDIRESETSOFT)(void);
 173 typedef void (AL_APIENTRY*LPALMIDIGAINSOFT)(ALfloat value);
 174 typedef ALint64SOFT (AL_APIENTRY*LPALGETINTEGER64SOFT)(ALenum pname);
 175 typedef void (AL_APIENTRY*LPALGETINTEGER64VSOFT)(ALenum pname, ALint64SOFT *values);
 176 typedef void (AL_APIENTRY*LPALLOADSOUNDFONTSOFT)(ALuint id, size_t(*cb)(ALvoid*,size_t,ALvoid*), ALvoid *user);
 177 #ifdef AL_ALEXT_PROTOTYPES
 178 AL_API void AL_APIENTRY alGenSoundfontsSOFT(ALsizei n, ALuint *ids);
 179 AL_API void AL_APIENTRY alDeleteSoundfontsSOFT(ALsizei n, const ALuint *ids);
 180 AL_API ALboolean AL_APIENTRY alIsSoundfontSOFT(ALuint id);
 181 AL_API void AL_APIENTRY alSoundfontSamplesSOFT(ALuint sfid, ALenum type, ALsizei count, const ALvoid *samples);
 182 AL_API void AL_APIENTRY alGetSoundfontSamplesSOFT(ALuint id, ALsizei offset, ALsizei count, ALenum type, ALvoid *samples);
 183 AL_API ALvoid* AL_APIENTRY alSoundfontMapSamplesSOFT(ALuint sfid, ALsizei offset, ALsizei length);
 184 AL_API void AL_APIENTRY alSoundfontUnmapSamplesSOFT(ALuint sfid);
 185 AL_API void AL_APIENTRY alGetSoundfontivSOFT(ALuint id, ALenum param, ALint *values);
 186 AL_API void AL_APIENTRY alSoundfontPresetsSOFT(ALuint id, ALsizei count, const ALuint *pids);
 187
 188 AL_API void AL_APIENTRY alGenPresetsSOFT(ALsizei n, ALuint *ids);
 189 AL_API void AL_APIENTRY alDeletePresetsSOFT(ALsizei n, const ALuint *ids);
 190 AL_API ALboolean AL_APIENTRY alIsPresetSOFT(ALuint id);
 191 AL_API void AL_APIENTRY alPresetiSOFT(ALuint id, ALenum param, ALint value);
 192 AL_API void AL_APIENTRY alPresetivSOFT(ALuint id, ALenum param, const ALint *values);
 193 AL_API void AL_APIENTRY alGetPresetivSOFT(ALuint id, ALenum param, ALint *values);
 194 AL_API void AL_APIENTRY alPresetFontsoundsSOFT(ALuint id, ALsizei count, const ALuint *fsids);
 195
 196 AL_API void AL_APIENTRY alGenFontsoundsSOFT(ALsizei n, ALuint *ids);
 197 AL_API void AL_APIENTRY alDeleteFontsoundsSOFT(ALsizei n, const ALuint *ids);
 198 AL_API ALboolean AL_APIENTRY alIsFontsoundSOFT(ALuint id);
 199 AL_API void AL_APIENTRY alFontsoundiSOFT(ALuint id, ALenum param, ALint value);
 200 AL_API void AL_APIENTRY alFontsound2iSOFT(ALuint id, ALenum param, ALint value1, ALint value2);
 201 AL_API void AL_APIENTRY alFontsoundivSOFT(ALuint id, ALenum param, const ALint *values);
 202 AL_API void AL_APIENTRY alGetFontsoundivSOFT(ALuint id, ALenum param, ALint *values);
 203 AL_API void AL_APIENTRY alFontsoundModulatoriSOFT(ALuint id, ALsizei stage, ALenum param, ALint value);
 204 AL_API void AL_APIENTRY alGetFontsoundModulatorivSOFT(ALuint id, ALsizei stage, ALenum param, ALint *values);
 205
 206 AL_API void AL_APIENTRY alMidiSoundfontSOFT(ALuint id);
 207 AL_API void AL_APIENTRY alMidiSoundfontvSOFT(ALsizei count, const ALuint *ids);
 208 AL_API void AL_APIENTRY alMidiEventSOFT(ALuint64SOFT time, ALenum event, ALsizei channel, ALsizei param1, ALsizei param2);
 209 AL_API void AL_APIENTRY alMidiSysExSOFT(ALuint64SOFT time, const ALbyte *data, ALsizei size);
 210 AL_API void AL_APIENTRY alMidiPlaySOFT(void);
 211 AL_API void AL_APIENTRY alMidiPauseSOFT(void);
 212 AL_API void AL_APIENTRY alMidiStopSOFT(void);
 213 AL_API void AL_APIENTRY alMidiResetSOFT(void);
 214 AL_API void AL_APIENTRY alMidiGainSOFT(ALfloat value);
 215 AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname);
 216 AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values);
 217 AL_API void AL_APIENTRY alLoadSoundfontSOFT(ALuint id, size_t(*cb)(ALvoid*,size_t,ALvoid*), ALvoid *user);
 218 #endif
 219 #endif
 220
 221 #ifndef ALC_SOFT_pause_device
 222 #define ALC_SOFT_pause_device 1
 223 typedef void (ALC_APIENTRY*LPALCDEVICEPAUSESOFT)(ALCdevice *device);
 224 typedef void (ALC_APIENTRY*LPALCDEVICERESUMESOFT)(ALCdevice *device);
 225 #ifdef AL_ALEXT_PROTOTYPES
 226 ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device);
 227 ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device);
 228 #endif
 229 #endif
 230
 231
 232 #ifdef IN_IDE_PARSER
 233 /* KDevelop's parser doesn't recognize the C99-standard restrict keyword, but
 234  * recent versions (at least 4.5.1) do recognize GCC's __restrict. */
 235 #define restrict __restrict
 236 /* KDevelop won't see the ALIGN macro from config.h when viewing files that
 237  * don't include it directly (e.g. headers). */
 238 #ifndef ALIGN
 239 #define ALIGN(x)
 240 #endif
 241 #endif
 242
 243
 244 typedef ALint64SOFT ALint64;
 245 typedef ALuint64SOFT ALuint64;
 246
 247 typedef ptrdiff_t ALintptrEXT;
 248 typedef ptrdiff_t ALsizeiptrEXT;
 249
 250 #ifndef U64
 251 #if defined(_MSC_VER)
 252 #define U64(x) ((ALuint64)(x##ui64))
 253 #elif SIZEOF_LONG == 8
 254 #define U64(x) ((ALuint64)(x##ul))
 255 #elif SIZEOF_LONG_LONG == 8
 256 #define U64(x) ((ALuint64)(x##ull))
 257 #endif
 258 #endif
 259
 260 #ifndef UINT64_MAX
 261 #define UINT64_MAX U64(18446744073709551615)
 262 #endif
 263
 264 #ifndef UNUSED
 265 #if defined(__cplusplus)
 266 #define UNUSED(x)
 267 #elif defined(__GNUC__)
 268 #define UNUSED(x) UNUSED_##x __attribute__((unused))
 269 #elif defined(__LCLINT__)
 270 #define UNUSED(x) /*@unused@*/ x
 271 #else
 272 #define UNUSED(x) x
 273 #endif
 274 #endif
 275
 276 #ifdef HAVE_GCC_FORMAT
 277 #define PRINTF_STYLE(x, y) __attribute__((format(printf, (x), (y))))
 278 #else
 279 #define PRINTF_STYLE(x, y)
 280 #endif
 281
 282 #if defined(__GNUC__) && defined(__i386__)
 283 /* force_align_arg_pointer is required for proper function arguments aligning
 284  * when SSE code is used. Some systems (Windows, QNX) do not guarantee our
 285  * thread functions will be properly aligned on the stack, even though GCC may
 286  * generate code with the assumption that it is. */
 287 #define FORCE_ALIGN __attribute__((force_align_arg_pointer))
 288 #else
 289 #define FORCE_ALIGN
 290 #endif
 291
 292
 293 static const union {
 294     ALuint u;
 295     ALubyte b[sizeof(ALuint)];
 296 } EndianTest = { 1 };
 297 #define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
 298
 299 #define COUNTOF(x) (sizeof((x))/sizeof((x)[0]))
 300
 301
 302 #define DERIVE_FROM_TYPE(t)          t t##_parent
 303 #define STATIC_CAST(to, obj)         (&(obj)->to##_parent)
 304 #define STATIC_UPCAST(to, from, obj) ((to*)((char*)(obj) - offsetof(to, from##_parent)))
 305
 306
 307 #define DECLARE_FORWARD(T1, T2, rettype, func)                                \
 308 rettype T1##_##func(T1 *obj)                                                  \
 309 { return T2##_##func(STATIC_CAST(T2, obj)); }
 310
 311 #define DECLARE_FORWARD1(T1, T2, rettype, func, argtype1)                     \
 312 rettype T1##_##func(T1 *obj, argtype1 a)                                      \
 313 { return T2##_##func(STATIC_CAST(T2, obj), a); }
 314
 315 #define DECLARE_FORWARD2(T1, T2, rettype, func, argtype1, argtype2)           \
 316 rettype T1##_##func(T1 *obj, argtype1 a, argtype2 b)                          \
 317 { return T2##_##func(STATIC_CAST(T2, obj), a, b); }
 318
 319 #define DECLARE_FORWARD3(T1, T2, rettype, func, argtype1, argtype2, argtype3) \
 320 rettype T1##_##func(T1 *obj, argtype1 a, argtype2 b, argtype3 c)              \
 321 { return T2##_##func(STATIC_CAST(T2, obj), a, b, c); }
 322
 323
 324 #define GET_VTABLE1(T1)     (&(T1##_vtable))
 325 #define GET_VTABLE2(T1, T2) (&(T1##_##T2##_vtable))
 326
 327 #define SET_VTABLE1(T1, obj)     ((obj)->vtbl = GET_VTABLE1(T1))
 328 #define SET_VTABLE2(T1, T2, obj) (STATIC_CAST(T2, obj)->vtbl = GET_VTABLE2(T1, T2))
 329
 330 #define DECLARE_THUNK(T1, T2, rettype, func)                                  \
 331 static rettype T1##_##T2##_##func(T2 *obj)                                    \
 332 { return T1##_##func(STATIC_UPCAST(T1, T2, obj)); }
 333
 334 #define DECLARE_THUNK1(T1, T2, rettype, func, argtype1)                       \
 335 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a)                        \
 336 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a); }
 337
 338 #define DECLARE_THUNK2(T1, T2, rettype, func, argtype1, argtype2)             \
 339 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a, argtype2 b)            \
 340 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a, b); }
 341
 342 #define DECLARE_THUNK3(T1, T2, rettype, func, argtype1, argtype2, argtype3)   \
 343 static rettype T1##_##T2##_##func(T2 *obj, argtype1 a, argtype2 b, argtype3 c) \
 344 { return T1##_##func(STATIC_UPCAST(T1, T2, obj), a, b, c); }
 345
 346
 347 /* Helper to extract an argument list for VCALL. Not used directly. */
 348 #define EXTRACT_VCALL_ARGS(...)  __VA_ARGS__))
 349
 350 /* Call a "virtual" method on an object, with arguments. */
 351 #define V(obj, func)  ((obj)->vtbl->func((obj), EXTRACT_VCALL_ARGS
 352 /* Call a "virtual" method on an object, with no arguments. */
 353 #define V0(obj, func) ((obj)->vtbl->func((obj) EXTRACT_VCALL_ARGS
 354
 355 #define DELETE_OBJ(obj) do {                                                  \
 356     if((obj) != NULL)                                                         \
 357     {                                                                         \
 358         V0((obj),Destruct)();                                                 \
 359         V0((obj),Delete)();                                                   \
 360     }                                                                         \
 361 } while(0)
 362
 363
 364 #ifdef __cplusplus
 365 extern "C" {
 366 #endif
 367
 368 struct Hrtf;
 369
 370
 371 #define DEFAULT_OUTPUT_RATE  (44100)
 372 #define MIN_OUTPUT_RATE      (8000)
 373
 374
 375 /* Find the next power-of-2 for non-power-of-2 numbers. */
 376 inline ALuint NextPowerOf2(ALuint value)
 377 {
 378     if(value > 0)
 379     {
 380         value--;
 381         value |= value>>1;
 382         value |= value>>2;
 383         value |= value>>4;
 384         value |= value>>8;
 385         value |= value>>16;
 386     }
 387     return value+1;
 388 }
 389
 390 /* Fast float-to-int conversion. Assumes the FPU is already in round-to-zero
 391  * mode. */
 392 inline ALint fastf2i(ALfloat f)
 393 {
 394 #ifdef HAVE_LRINTF
 395     return lrintf(f);
 396 #elif defined(_MSC_VER) && defined(_M_IX86)
 397     ALint i;
 398     __asm fld f
 399     __asm fistp i
 400     return i;
 401 #else
 402     return (ALint)f;
 403 #endif
 404 }
 405
 406 /* Fast float-to-uint conversion. Assumes the FPU is already in round-to-zero
 407  * mode. */
 408 inline ALuint fastf2u(ALfloat f)
 409 { return fastf2i(f); }
 410
 411
 412 enum DevProbe {
 413     ALL_DEVICE_PROBE,
 414     CAPTURE_DEVICE_PROBE
 415 };
 416
 417 typedef struct {
 418     ALCenum (*OpenPlayback)(ALCdevice*, const ALCchar*);
 419     void (*ClosePlayback)(ALCdevice*);
 420     ALCboolean (*ResetPlayback)(ALCdevice*);
 421     ALCboolean (*StartPlayback)(ALCdevice*);
 422     void (*StopPlayback)(ALCdevice*);
 423
 424     ALCenum (*OpenCapture)(ALCdevice*, const ALCchar*);
 425     void (*CloseCapture)(ALCdevice*);
 426     void (*StartCapture)(ALCdevice*);
 427     void (*StopCapture)(ALCdevice*);
 428     ALCenum (*CaptureSamples)(ALCdevice*, void*, ALCuint);
 429     ALCuint (*AvailableSamples)(ALCdevice*);
 430
 431     ALint64 (*GetLatency)(ALCdevice*);
 432 } BackendFuncs;
 433
 434 ALCboolean alc_solaris_init(BackendFuncs *func_list);
 435 void alc_solaris_deinit(void);
 436 void alc_solaris_probe(enum DevProbe type);
 437 ALCboolean alc_sndio_init(BackendFuncs *func_list);
 438 void alc_sndio_deinit(void);
 439 void alc_sndio_probe(enum DevProbe type);
 440 ALCboolean alcMMDevApiInit(BackendFuncs *func_list);
 441 void alcMMDevApiDeinit(void);
 442 void alcMMDevApiProbe(enum DevProbe type);
 443 ALCboolean alcDSoundInit(BackendFuncs *func_list);
 444 void alcDSoundDeinit(void);
 445 void alcDSoundProbe(enum DevProbe type);
 446 ALCboolean alcWinMMInit(BackendFuncs *FuncList);
 447 void alcWinMMDeinit(void);
 448 void alcWinMMProbe(enum DevProbe type);
 449 ALCboolean alc_pa_init(BackendFuncs *func_list);
 450 void alc_pa_deinit(void);
 451 void alc_pa_probe(enum DevProbe type);
 452 ALCboolean alc_wave_init(BackendFuncs *func_list);
 453 void alc_wave_deinit(void);
 454 void alc_wave_probe(enum DevProbe type);
 455 ALCboolean alc_ca_init(BackendFuncs *func_list);
 456 void alc_ca_deinit(void);
 457 void alc_ca_probe(enum DevProbe type);
 458 ALCboolean alc_opensl_init(BackendFuncs *func_list);
 459 void alc_opensl_deinit(void);
 460 void alc_opensl_probe(enum DevProbe type);
 461 ALCboolean alc_qsa_init(BackendFuncs *func_list);
 462 void alc_qsa_deinit(void);
 463 void alc_qsa_probe(enum DevProbe type);
 464
 465 struct ALCbackend;
 466
 467
 468 enum DistanceModel {
 469     InverseDistanceClamped  = AL_INVERSE_DISTANCE_CLAMPED,
 470     LinearDistanceClamped   = AL_LINEAR_DISTANCE_CLAMPED,
 471     ExponentDistanceClamped = AL_EXPONENT_DISTANCE_CLAMPED,
 472     InverseDistance  = AL_INVERSE_DISTANCE,
 473     LinearDistance   = AL_LINEAR_DISTANCE,
 474     ExponentDistance = AL_EXPONENT_DISTANCE,
 475     DisableDistance  = AL_NONE,
 476
 477     DefaultDistanceModel = InverseDistanceClamped
 478 };
 479
 480 enum Resampler {
 481     PointResampler,
 482     LinearResampler,
 483     CubicResampler,
 484
 485     ResamplerMax,
 486 };
 487
 488 enum Channel {
 489     FrontLeft = 0,
 490     FrontRight,
 491     FrontCenter,
 492     LFE,
 493     BackLeft,
 494     BackRight,
 495     BackCenter,
 496     SideLeft,
 497     SideRight,
 498
 499     MaxChannels,
 500 };
 501
 502
 503 /* Device formats */
 504 enum DevFmtType {
 505     DevFmtByte   = ALC_BYTE_SOFT,
 506     DevFmtUByte  = ALC_UNSIGNED_BYTE_SOFT,
 507     DevFmtShort  = ALC_SHORT_SOFT,
 508     DevFmtUShort = ALC_UNSIGNED_SHORT_SOFT,
 509     DevFmtInt    = ALC_INT_SOFT,
 510     DevFmtUInt   = ALC_UNSIGNED_INT_SOFT,
 511     DevFmtFloat  = ALC_FLOAT_SOFT,
 512
 513     DevFmtTypeDefault = DevFmtFloat
 514 };
 515 enum DevFmtChannels {
 516     DevFmtMono   = ALC_MONO_SOFT,
 517     DevFmtStereo = ALC_STEREO_SOFT,
 518     DevFmtQuad   = ALC_QUAD_SOFT,
 519     DevFmtX51    = ALC_5POINT1_SOFT,
 520     DevFmtX61    = ALC_6POINT1_SOFT,
 521     DevFmtX71    = ALC_7POINT1_SOFT,
 522
 523     /* Similar to 5.1, except using the side channels instead of back */
 524     DevFmtX51Side = 0x80000000,
 525
 526     DevFmtChannelsDefault = DevFmtStereo
 527 };
 528
 529 ALuint BytesFromDevFmt(enum DevFmtType type);
 530 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans);
 531 inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type)
 532 {
 533     return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
 534 }
 535
 536
 537 extern const struct EffectList {
 538     const char *name;
 539     int type;
 540     const char *ename;
 541     ALenum val;
 542 } EffectList[];
 543
 544
 545 enum DeviceType {
 546     Playback,
 547     Capture,
 548     Loopback
 549 };
 550
 551
 552 /* Size for temporary storage of buffer data, in ALfloats. Larger values need
 553  * more memory, while smaller values may need more iterations. The value needs
 554  * to be a sensible size, however, as it constrains the max stepping value used
 555  * for mixing, as well as the maximum number of samples per mixing iteration.
 556  */
 557 #define BUFFERSIZE (2048u)
 558
 559
 560 struct ALCdevice_struct
 561 {
 562     volatile RefCount ref;
 563
 564     ALCboolean Connected;
 565     enum DeviceType Type;
 566
 567     ALuint       Frequency;
 568     ALuint       UpdateSize;
 569     ALuint       NumUpdates;
 570     enum DevFmtChannels FmtChans;
 571     enum DevFmtType     FmtType;
 572
 573     ALCchar      *DeviceName;
 574
 575     volatile ALCenum LastError;
 576
 577     // Maximum number of sources that can be created
 578     ALuint       MaxNoOfSources;
 579     // Maximum number of slots that can be created
 580     ALuint       AuxiliaryEffectSlotMax;
 581
 582     ALCuint      NumMonoSources;
 583     ALCuint      NumStereoSources;
 584     ALuint       NumAuxSends;
 585
 586     // Map of Buffers for this device
 587     UIntMap BufferMap;
 588
 589     // Map of Effects for this device
 590     UIntMap EffectMap;
 591
 592     // Map of Filters for this device
 593     UIntMap FilterMap;
 594
 595     // Map of Soundfonts for this device
 596     UIntMap SfontMap;
 597
 598     // Map of Presets for this device
 599     UIntMap PresetMap;
 600
 601     // Map of Fontsounds for this device
 602     UIntMap FontsoundMap;
 603
 604     /* Default soundfont (accessible as ID 0) */
 605     struct ALsoundfont *DefaultSfont;
 606
 607     /* MIDI synth engine */
 608     struct MidiSynth *Synth;
 609
 610     /* HRTF filter tables */
 611     const struct Hrtf *Hrtf;
 612
 613     // Stereo-to-binaural filter
 614     struct bs2b *Bs2b;
 615     ALCint       Bs2bLevel;
 616
 617     // Device flags
 618     ALuint       Flags;
 619
 620     ALuint ChannelOffsets[MaxChannels];
 621
 622     enum Channel Speaker2Chan[MaxChannels];
 623     ALfloat SpeakerAngle[MaxChannels];
 624     ALuint  NumChan;
 625
 626     /* Temp storage used for mixing. +1 for the predictive sample. */
 627     ALIGN(16) ALfloat SampleData1[BUFFERSIZE+1];
 628     ALIGN(16) ALfloat SampleData2[BUFFERSIZE+1];
 629
 630     // Dry path buffer mix
 631     ALIGN(16) ALfloat DryBuffer[MaxChannels][BUFFERSIZE];
 632
 633     ALIGN(16) ALfloat ClickRemoval[MaxChannels];
 634     ALIGN(16) ALfloat PendingClicks[MaxChannels];
 635
 636     /* Default effect slot */
 637     struct ALeffectslot *DefaultSlot;
 638
 639     // Contexts created on this device
 640     ALCcontext *volatile ContextList;
 641
 642     struct ALCbackend *Backend;
 643
 644     BackendFuncs *Funcs;
 645     void         *ExtraData; // For the backend's use
 646
 647     ALCdevice *volatile next;
 648 };
 649
 650 // Frequency was requested by the app or config file
 651 #define DEVICE_FREQUENCY_REQUEST                 (1<<1)
 652 // Channel configuration was requested by the config file
 653 #define DEVICE_CHANNELS_REQUEST                  (1<<2)
 654 // Sample type was requested by the config file
 655 #define DEVICE_SAMPLE_TYPE_REQUEST               (1<<3)
 656 // HRTF was requested by the app
 657 #define DEVICE_HRTF_REQUEST                      (1<<4)
 658
 659 // Stereo sources cover 120-degree angles around +/-90
 660 #define DEVICE_WIDE_STEREO                       (1<<16)
 661
 662 // Specifies if the DSP is paused at user request
 663 #define DEVICE_PAUSED                            (1<<30)
 664
 665 // Specifies if the device is currently running
 666 #define DEVICE_RUNNING                           (1<<31)
 667
 668 /* Invalid channel offset */
 669 #define INVALID_OFFSET                           (~0u)
 670
 671
 672 /* Must be less than 15 characters (16 including terminating null) for
 673  * compatibility with pthread_setname_np limitations. */
 674 #define MIXER_THREAD_NAME "alsoft-mixer"
 675
 676
 677 struct ALCcontext_struct
 678 {
 679     volatile RefCount ref;
 680
 681     struct ALlistener *Listener;
 682
 683     UIntMap SourceMap;
 684     UIntMap EffectSlotMap;
 685
 686     volatile ALenum LastError;
 687
 688     volatile ALenum UpdateSources;
 689
 690     volatile enum DistanceModel DistanceModel;
 691     volatile ALboolean SourceDistanceModel;
 692
 693     volatile ALfloat DopplerFactor;
 694     volatile ALfloat DopplerVelocity;
 695     volatile ALfloat SpeedOfSound;
 696     volatile ALenum  DeferUpdates;
 697
 698     struct ALsource **ActiveSources;
 699     ALsizei           ActiveSourceCount;
 700     ALsizei           MaxActiveSources;
 701
 702     struct ALeffectslot **ActiveEffectSlots;
 703     ALsizei               ActiveEffectSlotCount;
 704     ALsizei               MaxActiveEffectSlots;
 705
 706     ALCdevice  *Device;
 707     const ALCchar *ExtensionList;
 708
 709     ALCcontext *volatile next;
 710 };
 711
 712 ALCcontext *GetContextRef(void);
 713
 714 void ALCcontext_IncRef(ALCcontext *context);
 715 void ALCcontext_DecRef(ALCcontext *context);
 716
 717 void AppendAllDevicesList(const ALCchar *name);
 718 void AppendCaptureDeviceList(const ALCchar *name);
 719
 720 ALint64 ALCdevice_GetLatencyDefault(ALCdevice *device);
 721
 722 void ALCdevice_Lock(ALCdevice *device);
 723 void ALCdevice_Unlock(ALCdevice *device);
 724 ALint64 ALCdevice_GetLatency(ALCdevice *device);
 725
 726 inline void LockContext(ALCcontext *context)
 727 { ALCdevice_Lock(context->Device); }
 728
 729 inline void UnlockContext(ALCcontext *context)
 730 { ALCdevice_Unlock(context->Device); }
 731
 732
 733 void *al_malloc(size_t alignment, size_t size);
 734 void *al_calloc(size_t alignment, size_t size);
 735 void al_free(void *ptr);
 736
 737
 738 typedef struct {
 739 #ifdef HAVE_FENV_H
 740     DERIVE_FROM_TYPE(fenv_t);
 741 #else
 742     int state;
 743 #endif
 744 #ifdef HAVE_SSE
 745     int sse_state;
 746 #endif
 747 } FPUCtl;
 748 void SetMixerFPUMode(FPUCtl *ctl);
 749 void RestoreFPUMode(const FPUCtl *ctl);
 750
 751
 752 typedef struct RingBuffer RingBuffer;
 753 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 754 void DestroyRingBuffer(RingBuffer *ring);
 755 ALsizei RingBufferSize(RingBuffer *ring);
 756 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 757 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 758
 759 void ReadALConfig(void);
 760 void FreeALConfig(void);
 761 int ConfigValueExists(const char *blockName, const char *keyName);
 762 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
 763 int GetConfigValueBool(const char *blockName, const char *keyName, int def);
 764 int ConfigValueStr(const char *blockName, const char *keyName, const char **ret);
 765 int ConfigValueInt(const char *blockName, const char *keyName, int *ret);
 766 int ConfigValueUInt(const char *blockName, const char *keyName, unsigned int *ret);
 767 int ConfigValueFloat(const char *blockName, const char *keyName, float *ret);
 768
 769 void SetRTPriority(void);
 770
 771 void SetDefaultChannelOrder(ALCdevice *device);
 772 void SetDefaultWFXChannelOrder(ALCdevice *device);
 773
 774 const ALCchar *DevFmtTypeString(enum DevFmtType type);
 775 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans);
 776
 777 #define HRIR_BITS        (7)
 778 #define HRIR_LENGTH      (1<<HRIR_BITS)
 779 #define HRIR_MASK        (HRIR_LENGTH-1)
 780 #define HRTFDELAY_BITS    (20)
 781 #define HRTFDELAY_FRACONE (1<<HRTFDELAY_BITS)
 782 #define HRTFDELAY_MASK    (HRTFDELAY_FRACONE-1)
 783 const struct Hrtf *GetHrtf(ALCdevice *device);
 784 void FindHrtfFormat(const ALCdevice *device, enum DevFmtChannels *chans, ALCuint *srate);
 785 void FreeHrtfs(void);
 786 ALuint GetHrtfIrSize(const struct Hrtf *Hrtf);
 787 ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3]);
 788 void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays);
 789 ALuint GetMovingHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat delta, ALint counter, ALfloat (*coeffs)[2], ALuint *delays, ALfloat (*coeffStep)[2], ALint *delayStep);
 790
 791
 792 extern FILE *LogFile;
 793
 794 #ifdef __GNUC__
 795 #define AL_PRINT(T, MSG, ...) fprintf(LogFile, "AL lib: %s %s: "MSG, T, __FUNCTION__ , ## __VA_ARGS__)
 796 #else
 797 void al_print(const char *type, const char *func, const char *fmt, ...) PRINTF_STYLE(3,4);
 798 #define AL_PRINT(T, MSG, ...) al_print((T), __FUNCTION__, MSG, __VA_ARGS__)
 799 #endif
 800
 801 enum LogLevel {
 802     NoLog,
 803     LogError,
 804     LogWarning,
 805     LogTrace,
 806     LogRef
 807 };
 808 extern enum LogLevel LogLevel;
 809
 810 #define TRACEREF(...) do {                                                    \
 811     if(LogLevel >= LogRef)                                                    \
 812         AL_PRINT("(--)", __VA_ARGS__);                                        \
 813 } while(0)
 814
 815 #define TRACE(...) do {                                                       \
 816     if(LogLevel >= LogTrace)                                                  \
 817         AL_PRINT("(II)", __VA_ARGS__);                                        \
 818 } while(0)
 819
 820 #define WARN(...) do {                                                        \
 821     if(LogLevel >= LogWarning)                                                \
 822         AL_PRINT("(WW)", __VA_ARGS__);                                        \
 823 } while(0)
 824
 825 #define ERR(...) do {                                                         \
 826     if(LogLevel >= LogError)                                                  \
 827         AL_PRINT("(EE)", __VA_ARGS__);                                        \
 828 } while(0)
 829
 830
 831 extern ALint RTPrioLevel;
 832
 833
 834 extern ALuint CPUCapFlags;
 835 enum {
 836     CPU_CAP_SSE    = 1<<0,
 837     CPU_CAP_SSE2   = 1<<1,
 838     CPU_CAP_NEON   = 1<<2,
 839 };
 840
 841 void FillCPUCaps(ALuint capfilter);
 842
 843
 844 /* Small hack to use a pointer-to-array type as a normal argument type.
 845  * Shouldn't be used directly. */
 846 typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
 847
 848
 849 #ifdef __cplusplus
 850 }
 851 #endif
 852
 853 #endif