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     TopFrontLeft,
 534     TopFrontRight,
 535     TopBackLeft,
 536     TopBackRight,
 537     BottomFrontLeft,
 538     BottomFrontRight,
 539     BottomBackLeft,
 540     BottomBackRight,
 541
 542     InvalidChannel
 543 };
 544
 545
 546 /* Device formats */
 547 enum DevFmtType {
 548     DevFmtByte   = ALC_BYTE_SOFT,
 549     DevFmtUByte  = ALC_UNSIGNED_BYTE_SOFT,
 550     DevFmtShort  = ALC_SHORT_SOFT,
 551     DevFmtUShort = ALC_UNSIGNED_SHORT_SOFT,
 552     DevFmtInt    = ALC_INT_SOFT,
 553     DevFmtUInt   = ALC_UNSIGNED_INT_SOFT,
 554     DevFmtFloat  = ALC_FLOAT_SOFT,
 555
 556     DevFmtTypeDefault = DevFmtFloat
 557 };
 558 enum DevFmtChannels {
 559     DevFmtMono   = ALC_MONO_SOFT,
 560     DevFmtStereo = ALC_STEREO_SOFT,
 561     DevFmtQuad   = ALC_QUAD_SOFT,
 562     DevFmtX51    = ALC_5POINT1_SOFT,
 563     DevFmtX61    = ALC_6POINT1_SOFT,
 564     DevFmtX71    = ALC_7POINT1_SOFT,
 565
 566     /* Similar to 5.1, except using rear channels instead of sides */
 567     DevFmtX51Rear = 0x80000000,
 568
 569     DevFmtChannelsDefault = DevFmtStereo
 570 };
 571 #define MAX_OUTPUT_CHANNELS  (8)
 572
 573 ALuint BytesFromDevFmt(enum DevFmtType type) DECL_CONST;
 574 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans) DECL_CONST;
 575 inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type)
 576 {
 577     return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
 578 }
 579
 580
 581 extern const struct EffectList {
 582     const char *name;
 583     int type;
 584     const char *ename;
 585     ALenum val;
 586 } EffectList[];
 587
 588
 589 enum DeviceType {
 590     Playback,
 591     Capture,
 592     Loopback
 593 };
 594
 595
 596 /* The maximum number of Ambisonics coefficients. For a given order (o), the
 597  * size needed will be (o+1)**2, thus zero-order has 1, first-order has 4,
 598  * second-order has 9, and third-order has 16. */
 599 #define MAX_AMBI_COEFFS 16
 600
 601 typedef struct ChannelConfig {
 602     ALfloat HOACoeff[MAX_AMBI_COEFFS];
 603     ALfloat FOACoeff[4];
 604 } ChannelConfig;
 605
 606
 607 #define HRTF_HISTORY_BITS   (6)
 608 #define HRTF_HISTORY_LENGTH (1<<HRTF_HISTORY_BITS)
 609 #define HRTF_HISTORY_MASK   (HRTF_HISTORY_LENGTH-1)
 610
 611 typedef struct HrtfState {
 612     alignas(16) ALfloat History[HRTF_HISTORY_LENGTH];
 613     alignas(16) ALfloat Values[HRIR_LENGTH][2];
 614 } HrtfState;
 615
 616 typedef struct HrtfParams {
 617     alignas(16) ALfloat Coeffs[HRIR_LENGTH][2];
 618     alignas(16) ALfloat CoeffStep[HRIR_LENGTH][2];
 619     ALuint Delay[2];
 620     ALint DelayStep[2];
 621 } HrtfParams;
 622
 623
 624 /* Size for temporary storage of buffer data, in ALfloats. Larger values need
 625  * more memory, while smaller values may need more iterations. The value needs
 626  * to be a sensible size, however, as it constrains the max stepping value used
 627  * for mixing, as well as the maximum number of samples per mixing iteration.
 628  */
 629 #define BUFFERSIZE (2048u)
 630
 631 struct ALCdevice_struct
 632 {
 633     RefCount ref;
 634
 635     ALCboolean Connected;
 636     enum DeviceType Type;
 637
 638     ALuint       Frequency;
 639     ALuint       UpdateSize;
 640     ALuint       NumUpdates;
 641     enum DevFmtChannels FmtChans;
 642     enum DevFmtType     FmtType;
 643
 644     al_string DeviceName;
 645
 646     ATOMIC(ALCenum) LastError;
 647
 648     // Maximum number of sources that can be created
 649     ALuint       MaxNoOfSources;
 650     // Maximum number of slots that can be created
 651     ALuint       AuxiliaryEffectSlotMax;
 652
 653     ALCuint      NumMonoSources;
 654     ALCuint      NumStereoSources;
 655     ALuint       NumAuxSends;
 656
 657     // Map of Buffers for this device
 658     UIntMap BufferMap;
 659
 660     // Map of Effects for this device
 661     UIntMap EffectMap;
 662
 663     // Map of Filters for this device
 664     UIntMap FilterMap;
 665
 666     // Map of Soundfonts for this device
 667     UIntMap SfontMap;
 668
 669     // Map of Presets for this device
 670     UIntMap PresetMap;
 671
 672     // Map of Fontsounds for this device
 673     UIntMap FontsoundMap;
 674
 675     /* Default soundfont (accessible as ID 0) */
 676     struct ALsoundfont *DefaultSfont;
 677
 678     /* MIDI synth engine */
 679     struct MidiSynth *Synth;
 680
 681     /* HRTF filter tables */
 682     const struct Hrtf *Hrtf;
 683     HrtfState Hrtf_State[MAX_OUTPUT_CHANNELS];
 684     HrtfParams Hrtf_Params[MAX_OUTPUT_CHANNELS];
 685     ALuint Hrtf_Offset;
 686
 687     // Stereo-to-binaural filter
 688     struct bs2b *Bs2b;
 689
 690     // Device flags
 691     ALuint       Flags;
 692
 693     enum Channel ChannelName[MAX_OUTPUT_CHANNELS];
 694     ChannelConfig Channel[MAX_OUTPUT_CHANNELS];
 695     ALuint NumChannels;
 696
 697     ALuint64 ClockBase;
 698     ALuint SamplesDone;
 699
 700     /* Temp storage used for each source when mixing. */
 701     alignas(16) ALfloat SourceData[BUFFERSIZE];
 702     alignas(16) ALfloat ResampledData[BUFFERSIZE];
 703     alignas(16) ALfloat FilteredData[BUFFERSIZE];
 704
 705     // Dry path buffer mix
 706     alignas(16) ALfloat (*DryBuffer)[BUFFERSIZE];
 707
 708     /* Running count of the mixer invocations, in 31.1 fixed point. This
 709      * actually increments *twice* when mixing, first at the start and then at
 710      * the end, so the bottom bit indicates if the device is currently mixing
 711      * and the upper bits indicates how many mixes have been done.
 712      */
 713     RefCount MixCount;
 714
 715     /* Default effect slot */
 716     struct ALeffectslot *DefaultSlot;
 717
 718     // Contexts created on this device
 719     ATOMIC(ALCcontext*) ContextList;
 720
 721     struct ALCbackend *Backend;
 722
 723     void *ExtraData; // For the backend's use
 724
 725     ALCdevice *volatile next;
 726
 727     /* Memory space used by the default slot (Playback devices only) */
 728     alignas(16) ALCbyte _slot_mem[];
 729 };
 730
 731 // Frequency was requested by the app or config file
 732 #define DEVICE_FREQUENCY_REQUEST                 (1<<1)
 733 // Channel configuration was requested by the config file
 734 #define DEVICE_CHANNELS_REQUEST                  (1<<2)
 735 // Sample type was requested by the config file
 736 #define DEVICE_SAMPLE_TYPE_REQUEST               (1<<3)
 737 // HRTF was requested by the app
 738 #define DEVICE_HRTF_REQUEST                      (1<<4)
 739
 740 // Specifies if the DSP is paused at user request
 741 #define DEVICE_PAUSED                            (1<<30)
 742
 743 // Specifies if the device is currently running
 744 #define DEVICE_RUNNING                           (1<<31)
 745
 746
 747 /* Nanosecond resolution for the device clock time. */
 748 #define DEVICE_CLOCK_RES  U64(1000000000)
 749
 750
 751 /* Must be less than 15 characters (16 including terminating null) for
 752  * compatibility with pthread_setname_np limitations. */
 753 #define MIXER_THREAD_NAME "alsoft-mixer"
 754
 755
 756 struct ALCcontext_struct
 757 {
 758     RefCount ref;
 759
 760     struct ALlistener *Listener;
 761
 762     UIntMap SourceMap;
 763     UIntMap EffectSlotMap;
 764
 765     ATOMIC(ALenum) LastError;
 766
 767     ATOMIC(ALenum) UpdateSources;
 768
 769     volatile enum DistanceModel DistanceModel;
 770     volatile ALboolean SourceDistanceModel;
 771
 772     volatile ALfloat DopplerFactor;
 773     volatile ALfloat DopplerVelocity;
 774     volatile ALfloat SpeedOfSound;
 775     volatile ALenum  DeferUpdates;
 776
 777     struct ALvoice *Voices;
 778     ALsizei VoiceCount;
 779     ALsizei MaxVoices;
 780
 781     VECTOR(struct ALeffectslot*) ActiveAuxSlots;
 782
 783     ALCdevice  *Device;
 784     const ALCchar *ExtensionList;
 785
 786     ALCcontext *volatile next;
 787
 788     /* Memory space used by the listener */
 789     alignas(16) ALCbyte _listener_mem[];
 790 };
 791
 792 ALCcontext *GetContextRef(void);
 793
 794 void ALCcontext_IncRef(ALCcontext *context);
 795 void ALCcontext_DecRef(ALCcontext *context);
 796
 797 void AppendAllDevicesList(const ALCchar *name);
 798 void AppendCaptureDeviceList(const ALCchar *name);
 799
 800 void ALCdevice_Lock(ALCdevice *device);
 801 void ALCdevice_Unlock(ALCdevice *device);
 802 ALint64 ALCdevice_GetLatency(ALCdevice *device);
 803
 804 void ALCcontext_DeferUpdates(ALCcontext *context);
 805 void ALCcontext_ProcessUpdates(ALCcontext *context);
 806
 807 inline void LockContext(ALCcontext *context)
 808 { ALCdevice_Lock(context->Device); }
 809
 810 inline void UnlockContext(ALCcontext *context)
 811 { ALCdevice_Unlock(context->Device); }
 812
 813
 814 void *al_malloc(size_t alignment, size_t size);
 815 void *al_calloc(size_t alignment, size_t size);
 816 void al_free(void *ptr);
 817
 818
 819 typedef struct {
 820 #ifdef HAVE_FENV_H
 821     DERIVE_FROM_TYPE(fenv_t);
 822 #else
 823     int state;
 824 #endif
 825 #ifdef HAVE_SSE
 826     int sse_state;
 827 #endif
 828 } FPUCtl;
 829 void SetMixerFPUMode(FPUCtl *ctl);
 830 void RestoreFPUMode(const FPUCtl *ctl);
 831
 832
 833 typedef struct RingBuffer RingBuffer;
 834 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 835 void DestroyRingBuffer(RingBuffer *ring);
 836 ALsizei RingBufferSize(RingBuffer *ring);
 837 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 838 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 839
 840 void ReadALConfig(void);
 841 void FreeALConfig(void);
 842 int ConfigValueExists(const char *blockName, const char *keyName);
 843 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
 844 int GetConfigValueBool(const char *blockName, const char *keyName, int def);
 845 int ConfigValueStr(const char *blockName, const char *keyName, const char **ret);
 846 int ConfigValueInt(const char *blockName, const char *keyName, int *ret);
 847 int ConfigValueUInt(const char *blockName, const char *keyName, unsigned int *ret);
 848 int ConfigValueFloat(const char *blockName, const char *keyName, float *ret);
 849 int ConfigValueBool(const char *blockName, const char *keyName, int *ret);
 850
 851 void SetRTPriority(void);
 852
 853 void SetDefaultChannelOrder(ALCdevice *device);
 854 void SetDefaultWFXChannelOrder(ALCdevice *device);
 855
 856 const ALCchar *DevFmtTypeString(enum DevFmtType type) DECL_CONST;
 857 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans) DECL_CONST;
 858
 859 /**
 860  * GetChannelIdxByName
 861  *
 862  * Returns the device's channel index given a channel name (e.g. FrontCenter),
 863  * or -1 if it doesn't exist.
 864  */
 865 inline ALint GetChannelIdxByName(const ALCdevice *device, enum Channel chan)
 866 {
 867     ALint i = 0;
 868     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 869     {
 870         if(device->ChannelName[i] == chan)
 871             return i;
 872     }
 873     return -1;
 874 }
 875
 876
 877 extern FILE *LogFile;
 878
 879 #if defined(__GNUC__) && !defined(IN_IDE_PARSER)
 880 #define AL_PRINT(T, MSG, ...) fprintf(LogFile, "AL lib: %s %s: "MSG, T, __FUNCTION__ , ## __VA_ARGS__)
 881 #else
 882 void al_print(const char *type, const char *func, const char *fmt, ...) DECL_FORMAT(printf, 3,4);
 883 #define AL_PRINT(T, ...) al_print((T), __FUNCTION__, __VA_ARGS__)
 884 #endif
 885
 886 enum LogLevel {
 887     NoLog,
 888     LogError,
 889     LogWarning,
 890     LogTrace,
 891     LogRef
 892 };
 893 extern enum LogLevel LogLevel;
 894
 895 #define TRACEREF(...) do {                                                    \
 896     if(LogLevel >= LogRef)                                                    \
 897         AL_PRINT("(--)", __VA_ARGS__);                                        \
 898 } while(0)
 899
 900 #define TRACE(...) do {                                                       \
 901     if(LogLevel >= LogTrace)                                                  \
 902         AL_PRINT("(II)", __VA_ARGS__);                                        \
 903 } while(0)
 904
 905 #define WARN(...) do {                                                        \
 906     if(LogLevel >= LogWarning)                                                \
 907         AL_PRINT("(WW)", __VA_ARGS__);                                        \
 908 } while(0)
 909
 910 #define ERR(...) do {                                                         \
 911     if(LogLevel >= LogError)                                                  \
 912         AL_PRINT("(EE)", __VA_ARGS__);                                        \
 913 } while(0)
 914
 915
 916 extern ALint RTPrioLevel;
 917
 918
 919 extern ALuint CPUCapFlags;
 920 enum {
 921     CPU_CAP_SSE    = 1<<0,
 922     CPU_CAP_SSE2   = 1<<1,
 923     CPU_CAP_SSE4_1 = 1<<2,
 924     CPU_CAP_NEON   = 1<<3,
 925 };
 926
 927 void FillCPUCaps(ALuint capfilter);
 928
 929 FILE *OpenDataFile(const char *fname, const char *subdir);
 930
 931 /* Small hack to use a pointer-to-array type as a normal argument type.
 932  * Shouldn't be used directly. */
 933 typedef ALfloat ALfloatBUFFERSIZE[BUFFERSIZE];
 934
 935
 936 #ifdef __cplusplus
 937 }
 938 #endif
 939
 940 #endif