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