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
   9 #ifdef HAVE_FENV_H
  10 #include <fenv.h>
  11 #endif
  12
  13 #ifdef HAVE_FPU_CONTROL_H
  14 #include <fpu_control.h>
  15 #endif
  16
  17 #include "AL/al.h"
  18 #include "AL/alc.h"
  19 #include "AL/alext.h"
  20
  21 /* Define int64_t and uint64_t types */
  22 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  23 #include <inttypes.h>
  24 #elif defined(_WIN32) && defined(__GNUC__)
  25 #include <stdint.h>
  26 #elif defined(_WIN32)
  27 typedef __int64 int64_t;
  28 typedef unsigned __int64 uint64_t;
  29 #else
  30 /* Fallback if nothing above works */
  31 #include <inttypes.h>
  32 #endif
  33
  34 #ifndef AL_SOFT_deferred_updates
  35 #define AL_SOFT_deferred_updates 1
  36 #define AL_DEFERRED_UPDATES_SOFT                 0xC002
  37 typedef ALvoid (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void);
  38 typedef ALvoid (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void);
  39 #ifdef AL_ALEXT_PROTOTYPES
  40 AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void);
  41 AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void);
  42 #endif
  43 #endif
  44
  45 #ifndef AL_SOFT_source_latency
  46 #define AL_SOFT_source_latency 1
  47 #define AL_SAMPLE_OFFSET_LATENCY_SOFT            0x1200
  48 #define AL_SEC_OFFSET_LATENCY_SOFT               0x1201
  49 typedef int64_t ALint64SOFT;
  50 typedef uint64_t ALuint64SOFT;
  51 typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*);
  52 typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*);
  53 typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*);
  54 typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*);
  55 typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*);
  56 typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*);
  57 #ifdef AL_ALEXT_PROTOTYPES
  58 AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value);
  59 AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3);
  60 AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values);
  61 AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value);
  62 AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3);
  63 AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values);
  64 #endif
  65 #endif
  66
  67
  68 #if defined(HAVE_STDINT_H)
  69 #include <stdint.h>
  70 typedef int64_t ALint64;
  71 typedef uint64_t ALuint64;
  72 #elif defined(HAVE___INT64)
  73 typedef __int64 ALint64;
  74 typedef unsigned __int64 ALuint64;
  75 #elif (SIZEOF_LONG == 8)
  76 typedef long ALint64;
  77 typedef unsigned long ALuint64;
  78 #elif (SIZEOF_LONG_LONG == 8)
  79 typedef long long ALint64;
  80 typedef unsigned long long ALuint64;
  81 #endif
  82
  83 typedef ptrdiff_t ALintptrEXT;
  84 typedef ptrdiff_t ALsizeiptrEXT;
  85
  86 #define MAKEU64(x,y) (((ALuint64)(x)<<32)|(ALuint64)(y))
  87
  88 #ifdef HAVE_GCC_FORMAT
  89 #define PRINTF_STYLE(x, y) __attribute__((format(printf, (x), (y))))
  90 #else
  91 #define PRINTF_STYLE(x, y)
  92 #endif
  93
  94 #if defined(HAVE_RESTRICT)
  95 #define RESTRICT restrict
  96 #elif defined(HAVE___RESTRICT)
  97 #define RESTRICT __restrict
  98 #else
  99 #define RESTRICT
 100 #endif
 101
 102
 103 static const union {
 104     ALuint u;
 105     ALubyte b[sizeof(ALuint)];
 106 } EndianTest = { 1 };
 107 #define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
 108
 109 #define COUNTOF(x) (sizeof((x))/sizeof((x)[0]))
 110
 111 #ifdef _WIN32
 112
 113 #include <windows.h>
 114
 115 typedef DWORD pthread_key_t;
 116 int pthread_key_create(pthread_key_t *key, void (*callback)(void*));
 117 int pthread_key_delete(pthread_key_t key);
 118 void *pthread_getspecific(pthread_key_t key);
 119 int pthread_setspecific(pthread_key_t key, void *val);
 120
 121 #define HAVE_DYNLOAD 1
 122 void *LoadLib(const char *name);
 123 void CloseLib(void *handle);
 124 void *GetSymbol(void *handle, const char *name);
 125
 126 WCHAR *strdupW(const WCHAR *str);
 127
 128 typedef LONG pthread_once_t;
 129 #define PTHREAD_ONCE_INIT 0
 130 void pthread_once(pthread_once_t *once, void (*callback)(void));
 131
 132 static __inline int sched_yield(void)
 133 { SwitchToThread(); return 0; }
 134
 135 #else
 136
 137 #include <unistd.h>
 138 #include <assert.h>
 139 #include <pthread.h>
 140 #include <sys/time.h>
 141 #include <time.h>
 142 #include <errno.h>
 143
 144 #define IsBadWritePtr(a,b) ((a) == NULL && (b) != 0)
 145
 146 typedef pthread_mutex_t CRITICAL_SECTION;
 147 void InitializeCriticalSection(CRITICAL_SECTION *cs);
 148 void DeleteCriticalSection(CRITICAL_SECTION *cs);
 149 void EnterCriticalSection(CRITICAL_SECTION *cs);
 150 void LeaveCriticalSection(CRITICAL_SECTION *cs);
 151
 152 ALuint timeGetTime(void);
 153 void Sleep(ALuint t);
 154
 155 #if defined(HAVE_DLFCN_H)
 156 #define HAVE_DYNLOAD 1
 157 void *LoadLib(const char *name);
 158 void CloseLib(void *handle);
 159 void *GetSymbol(void *handle, const char *name);
 160 #endif
 161
 162 #endif
 163
 164 typedef void *volatile XchgPtr;
 165
 166 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
 167 typedef ALuint RefCount;
 168 static __inline RefCount IncrementRef(volatile RefCount *ptr)
 169 { return __sync_add_and_fetch(ptr, 1); }
 170 static __inline RefCount DecrementRef(volatile RefCount *ptr)
 171 { return __sync_sub_and_fetch(ptr, 1); }
 172
 173 static __inline int ExchangeInt(volatile int *ptr, int newval)
 174 {
 175     return __sync_lock_test_and_set(ptr, newval);
 176 }
 177 static __inline void *ExchangePtr(XchgPtr *ptr, void *newval)
 178 {
 179     return __sync_lock_test_and_set(ptr, newval);
 180 }
 181 static __inline ALboolean CompExchangeInt(volatile int *ptr, int oldval, int newval)
 182 {
 183     return __sync_bool_compare_and_swap(ptr, oldval, newval);
 184 }
 185 static __inline ALboolean CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
 186 {
 187     return __sync_bool_compare_and_swap(ptr, oldval, newval);
 188 }
 189
 190 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 191
 192 static __inline int xaddl(volatile int *dest, int incr)
 193 {
 194     int ret;
 195     __asm__ __volatile__("lock; xaddl %0,(%1)"
 196                          : "=r" (ret)
 197                          : "r" (dest), "0" (incr)
 198                          : "memory");
 199     return ret;
 200 }
 201
 202 typedef int RefCount;
 203 static __inline RefCount IncrementRef(volatile RefCount *ptr)
 204 { return xaddl(ptr, 1)+1; }
 205 static __inline RefCount DecrementRef(volatile RefCount *ptr)
 206 { return xaddl(ptr, -1)-1; }
 207
 208 static __inline int ExchangeInt(volatile int *dest, int newval)
 209 {
 210     int ret;
 211     __asm__ __volatile__("lock; xchgl %0,(%1)"
 212                          : "=r" (ret)
 213                          : "r" (dest), "0" (newval)
 214                          : "memory");
 215     return ret;
 216 }
 217
 218 static __inline ALboolean CompExchangeInt(volatile int *dest, int oldval, int newval)
 219 {
 220     int ret;
 221     __asm__ __volatile__("lock; cmpxchgl %2,(%1)"
 222                          : "=a" (ret)
 223                          : "r" (dest), "r" (newval), "0" (oldval)
 224                          : "memory");
 225     return ret == oldval;
 226 }
 227
 228 static __inline void *ExchangePtr(XchgPtr *dest, void *newval)
 229 {
 230     void *ret;
 231     __asm__ __volatile__(
 232 #ifdef __i386__
 233                          "lock; xchgl %0,(%1)"
 234 #else
 235                          "lock; xchgq %0,(%1)"
 236 #endif
 237                          : "=r" (ret)
 238                          : "r" (dest), "0" (newval)
 239                          : "memory"
 240     );
 241     return ret;
 242 }
 243
 244 static __inline ALboolean CompExchangePtr(XchgPtr *dest, void *oldval, void *newval)
 245 {
 246     void *ret;
 247     __asm__ __volatile__(
 248 #ifdef __i386__
 249                          "lock; cmpxchgl %2,(%1)"
 250 #else
 251                          "lock; cmpxchgq %2,(%1)"
 252 #endif
 253                          : "=a" (ret)
 254                          : "r" (dest), "r" (newval), "0" (oldval)
 255                          : "memory"
 256     );
 257     return ret == oldval;
 258 }
 259
 260 #elif defined(_WIN32)
 261
 262 typedef LONG RefCount;
 263 static __inline RefCount IncrementRef(volatile RefCount *ptr)
 264 { return InterlockedIncrement(ptr); }
 265 static __inline RefCount DecrementRef(volatile RefCount *ptr)
 266 { return InterlockedDecrement(ptr); }
 267
 268 extern ALbyte LONG_size_does_not_match_int[(sizeof(LONG)==sizeof(int))?1:-1];
 269
 270 static __inline int ExchangeInt(volatile int *ptr, int newval)
 271 {
 272     union {
 273         volatile int *i;
 274         volatile LONG *l;
 275     } u = { ptr };
 276     return InterlockedExchange(u.l, newval);
 277 }
 278 static __inline void *ExchangePtr(XchgPtr *ptr, void *newval)
 279 {
 280     return InterlockedExchangePointer(ptr, newval);
 281 }
 282 static __inline ALboolean CompExchangeInt(volatile int *ptr, int oldval, int newval)
 283 {
 284     union {
 285         volatile int *i;
 286         volatile LONG *l;
 287     } u = { ptr };
 288     return InterlockedCompareExchange(u.l, newval, oldval) == oldval;
 289 }
 290 static __inline ALboolean CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
 291 {
 292     return InterlockedCompareExchangePointer(ptr, newval, oldval) == oldval;
 293 }
 294
 295 #elif defined(__APPLE__)
 296
 297 #include <libkern/OSAtomic.h>
 298
 299 typedef int32_t RefCount;
 300 static __inline RefCount IncrementRef(volatile RefCount *ptr)
 301 { return OSAtomicIncrement32Barrier(ptr); }
 302 static __inline RefCount DecrementRef(volatile RefCount *ptr)
 303 { return OSAtomicDecrement32Barrier(ptr); }
 304
 305 static __inline int ExchangeInt(volatile int *ptr, int newval)
 306 {
 307     /* Really? No regular old atomic swap? */
 308     int oldval;
 309     do {
 310         oldval = *ptr;
 311     } while(!OSAtomicCompareAndSwap32Barrier(oldval, newval, ptr));
 312     return oldval;
 313 }
 314 static __inline void *ExchangePtr(XchgPtr *ptr, void *newval)
 315 {
 316     void *oldval;
 317     do {
 318         oldval = *ptr;
 319     } while(!OSAtomicCompareAndSwapPtrBarrier(oldval, newval, ptr));
 320     return oldval;
 321 }
 322 static __inline ALboolean CompExchangeInt(volatile int *ptr, int oldval, int newval)
 323 {
 324     return OSAtomicCompareAndSwap32Barrier(oldval, newval, ptr);
 325 }
 326 static __inline ALboolean CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
 327 {
 328     return OSAtomicCompareAndSwapPtrBarrier(oldval, newval, ptr);
 329 }
 330
 331 #else
 332 #error "No atomic functions available on this platform!"
 333 typedef ALuint RefCount;
 334 #endif
 335
 336
 337 typedef struct {
 338     volatile RefCount read_count;
 339     volatile RefCount write_count;
 340     volatile ALenum read_lock;
 341     volatile ALenum read_entry_lock;
 342     volatile ALenum write_lock;
 343 } RWLock;
 344
 345 void RWLockInit(RWLock *lock);
 346 void ReadLock(RWLock *lock);
 347 void ReadUnlock(RWLock *lock);
 348 void WriteLock(RWLock *lock);
 349 void WriteUnlock(RWLock *lock);
 350
 351
 352 typedef struct UIntMap {
 353     struct {
 354         ALuint key;
 355         ALvoid *value;
 356     } *array;
 357     ALsizei size;
 358     ALsizei maxsize;
 359     ALsizei limit;
 360     RWLock lock;
 361 } UIntMap;
 362 extern UIntMap TlsDestructor;
 363
 364 void InitUIntMap(UIntMap *map, ALsizei limit);
 365 void ResetUIntMap(UIntMap *map);
 366 ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value);
 367 ALvoid *RemoveUIntMapKey(UIntMap *map, ALuint key);
 368 ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key);
 369
 370 static __inline void LockUIntMapRead(UIntMap *map)
 371 { ReadLock(&map->lock); }
 372 static __inline void UnlockUIntMapRead(UIntMap *map)
 373 { ReadUnlock(&map->lock); }
 374 static __inline void LockUIntMapWrite(UIntMap *map)
 375 { WriteLock(&map->lock); }
 376 static __inline void UnlockUIntMapWrite(UIntMap *map)
 377 { WriteUnlock(&map->lock); }
 378
 379 #include "alListener.h"
 380 #include "alu.h"
 381
 382 #ifdef __cplusplus
 383 extern "C" {
 384 #endif
 385
 386
 387 #define DEFAULT_OUTPUT_RATE        (44100)
 388 #define MIN_OUTPUT_RATE            (8000)
 389
 390 #define SPEEDOFSOUNDMETRESPERSEC   (343.3f)
 391 #define AIRABSORBGAINHF            (0.99426f) /* -0.05dB */
 392
 393 #define LOWPASSFREQREF             (5000)
 394
 395
 396 struct Hrtf;
 397
 398
 399 // Find the next power-of-2 for non-power-of-2 numbers.
 400 static __inline ALuint NextPowerOf2(ALuint value)
 401 {
 402     ALuint powerOf2 = 1;
 403
 404     if(value)
 405     {
 406         value--;
 407         while(value)
 408         {
 409             value >>= 1;
 410             powerOf2 <<= 1;
 411         }
 412     }
 413     return powerOf2;
 414 }
 415
 416 /* Fast float-to-int conversion. Assumes the FPU is already in round-to-zero
 417  * mode. */
 418 static __inline ALint fastf2i(ALfloat f)
 419 {
 420     ALint i;
 421 #if defined(_MSC_VER) && defined(_M_IX86)
 422     __asm fld f
 423     __asm fistp i
 424 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 425     __asm__ __volatile__("flds %1\n\t"
 426                          "fistpl %0\n\t"
 427                          : "=m" (i)
 428                          : "m" (f));
 429 #else
 430     i = (ALint)f;
 431 #endif
 432     return i;
 433 }
 434
 435 /* Fast float-to-uint conversion. Assumes the FPU is already in round-to-zero
 436  * mode. */
 437 static __inline ALuint fastf2u(ALfloat f)
 438 { return fastf2i(f); }
 439
 440
 441 enum DevProbe {
 442     ALL_DEVICE_PROBE,
 443     CAPTURE_DEVICE_PROBE
 444 };
 445
 446 typedef struct {
 447     ALCenum (*OpenPlayback)(ALCdevice*, const ALCchar*);
 448     void (*ClosePlayback)(ALCdevice*);
 449     ALCboolean (*ResetPlayback)(ALCdevice*);
 450     ALCboolean (*StartPlayback)(ALCdevice*);
 451     void (*StopPlayback)(ALCdevice*);
 452
 453     ALCenum (*OpenCapture)(ALCdevice*, const ALCchar*);
 454     void (*CloseCapture)(ALCdevice*);
 455     void (*StartCapture)(ALCdevice*);
 456     void (*StopCapture)(ALCdevice*);
 457     ALCenum (*CaptureSamples)(ALCdevice*, void*, ALCuint);
 458     ALCuint (*AvailableSamples)(ALCdevice*);
 459
 460     void (*Lock)(ALCdevice*);
 461     void (*Unlock)(ALCdevice*);
 462
 463     ALint64 (*GetLatency)(ALCdevice*);
 464 } BackendFuncs;
 465
 466 struct BackendInfo {
 467     const char *name;
 468     ALCboolean (*Init)(BackendFuncs*);
 469     void (*Deinit)(void);
 470     void (*Probe)(enum DevProbe);
 471     BackendFuncs Funcs;
 472 };
 473
 474 ALCboolean alc_alsa_init(BackendFuncs *func_list);
 475 void alc_alsa_deinit(void);
 476 void alc_alsa_probe(enum DevProbe type);
 477 ALCboolean alc_oss_init(BackendFuncs *func_list);
 478 void alc_oss_deinit(void);
 479 void alc_oss_probe(enum DevProbe type);
 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 alcMMDevApiInit(BackendFuncs *func_list);
 487 void alcMMDevApiDeinit(void);
 488 void alcMMDevApiProbe(enum DevProbe type);
 489 ALCboolean alcDSoundInit(BackendFuncs *func_list);
 490 void alcDSoundDeinit(void);
 491 void alcDSoundProbe(enum DevProbe type);
 492 ALCboolean alcWinMMInit(BackendFuncs *FuncList);
 493 void alcWinMMDeinit(void);
 494 void alcWinMMProbe(enum DevProbe type);
 495 ALCboolean alc_pa_init(BackendFuncs *func_list);
 496 void alc_pa_deinit(void);
 497 void alc_pa_probe(enum DevProbe type);
 498 ALCboolean alc_wave_init(BackendFuncs *func_list);
 499 void alc_wave_deinit(void);
 500 void alc_wave_probe(enum DevProbe type);
 501 ALCboolean alc_pulse_init(BackendFuncs *func_list);
 502 void alc_pulse_deinit(void);
 503 void alc_pulse_probe(enum DevProbe type);
 504 ALCboolean alc_ca_init(BackendFuncs *func_list);
 505 void alc_ca_deinit(void);
 506 void alc_ca_probe(enum DevProbe type);
 507 ALCboolean alc_opensl_init(BackendFuncs *func_list);
 508 void alc_opensl_deinit(void);
 509 void alc_opensl_probe(enum DevProbe type);
 510 ALCboolean alc_null_init(BackendFuncs *func_list);
 511 void alc_null_deinit(void);
 512 void alc_null_probe(enum DevProbe type);
 513 ALCboolean alc_loopback_init(BackendFuncs *func_list);
 514 void alc_loopback_deinit(void);
 515 void alc_loopback_probe(enum DevProbe type);
 516
 517
 518 /* Device formats */
 519 enum DevFmtType {
 520     DevFmtByte   = ALC_BYTE_SOFT,
 521     DevFmtUByte  = ALC_UNSIGNED_BYTE_SOFT,
 522     DevFmtShort  = ALC_SHORT_SOFT,
 523     DevFmtUShort = ALC_UNSIGNED_SHORT_SOFT,
 524     DevFmtInt    = ALC_INT_SOFT,
 525     DevFmtUInt   = ALC_UNSIGNED_INT_SOFT,
 526     DevFmtFloat  = ALC_FLOAT_SOFT,
 527
 528     DevFmtTypeDefault = DevFmtFloat
 529 };
 530 enum DevFmtChannels {
 531     DevFmtMono   = ALC_MONO_SOFT,
 532     DevFmtStereo = ALC_STEREO_SOFT,
 533     DevFmtQuad   = ALC_QUAD_SOFT,
 534     DevFmtX51    = ALC_5POINT1_SOFT,
 535     DevFmtX61    = ALC_6POINT1_SOFT,
 536     DevFmtX71    = ALC_7POINT1_SOFT,
 537
 538     /* Similar to 5.1, except using the side channels instead of back */
 539     DevFmtX51Side = 0x80000000,
 540
 541     DevFmtChannelsDefault = DevFmtStereo
 542 };
 543
 544 ALuint BytesFromDevFmt(enum DevFmtType type);
 545 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans);
 546 static __inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans,
 547                                            enum DevFmtType type)
 548 {
 549     return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
 550 }
 551
 552
 553 extern const struct EffectList {
 554     const char *name;
 555     int type;
 556     const char *ename;
 557     ALenum val;
 558 } EffectList[];
 559
 560
 561 enum DeviceType {
 562     Playback,
 563     Capture,
 564     Loopback
 565 };
 566
 567 struct ALCdevice_struct
 568 {
 569     volatile RefCount ref;
 570
 571     ALCboolean Connected;
 572     enum DeviceType Type;
 573
 574     CRITICAL_SECTION Mutex;
 575
 576     ALuint       Frequency;
 577     ALuint       UpdateSize;
 578     ALuint       NumUpdates;
 579     enum DevFmtChannels FmtChans;
 580     enum DevFmtType     FmtType;
 581
 582     ALCchar      *DeviceName;
 583
 584     volatile ALCenum LastError;
 585
 586     // Maximum number of sources that can be created
 587     ALuint       MaxNoOfSources;
 588     // Maximum number of slots that can be created
 589     ALuint       AuxiliaryEffectSlotMax;
 590
 591     ALCuint      NumMonoSources;
 592     ALCuint      NumStereoSources;
 593     ALuint       NumAuxSends;
 594
 595     // Map of Buffers for this device
 596     UIntMap BufferMap;
 597
 598     // Map of Effects for this device
 599     UIntMap EffectMap;
 600
 601     // Map of Filters for this device
 602     UIntMap FilterMap;
 603
 604     /* HRTF filter tables */
 605     const struct Hrtf *Hrtf;
 606
 607     // Stereo-to-binaural filter
 608     struct bs2b *Bs2b;
 609     ALCint       Bs2bLevel;
 610
 611     // Device flags
 612     ALuint       Flags;
 613
 614     enum Channel DevChannels[MaxChannels];
 615
 616     enum Channel Speaker2Chan[MaxChannels];
 617     ALfloat SpeakerAngle[MaxChannels];
 618     ALuint  NumChan;
 619
 620     // Dry path buffer mix
 621     ALIGN(16) ALfloat DryBuffer[MaxChannels][BUFFERSIZE];
 622
 623     ALIGN(16) ALfloat ClickRemoval[MaxChannels];
 624     ALIGN(16) ALfloat PendingClicks[MaxChannels];
 625
 626     /* Default effect slot */
 627     struct ALeffectslot *DefaultSlot;
 628
 629     // Contexts created on this device
 630     ALCcontext *volatile ContextList;
 631
 632     BackendFuncs *Funcs;
 633     void         *ExtraData; // For the backend's use
 634
 635     ALCdevice *volatile next;
 636 };
 637
 638 #define ALCdevice_OpenPlayback(a,b)      ((a)->Funcs->OpenPlayback((a), (b)))
 639 #define ALCdevice_ClosePlayback(a)       ((a)->Funcs->ClosePlayback((a)))
 640 #define ALCdevice_ResetPlayback(a)       ((a)->Funcs->ResetPlayback((a)))
 641 #define ALCdevice_StartPlayback(a)       ((a)->Funcs->StartPlayback((a)))
 642 #define ALCdevice_StopPlayback(a)        ((a)->Funcs->StopPlayback((a)))
 643 #define ALCdevice_OpenCapture(a,b)       ((a)->Funcs->OpenCapture((a), (b)))
 644 #define ALCdevice_CloseCapture(a)        ((a)->Funcs->CloseCapture((a)))
 645 #define ALCdevice_StartCapture(a)        ((a)->Funcs->StartCapture((a)))
 646 #define ALCdevice_StopCapture(a)         ((a)->Funcs->StopCapture((a)))
 647 #define ALCdevice_CaptureSamples(a,b,c)  ((a)->Funcs->CaptureSamples((a), (b), (c)))
 648 #define ALCdevice_AvailableSamples(a)    ((a)->Funcs->AvailableSamples((a)))
 649 #define ALCdevice_Lock(a)                ((a)->Funcs->Lock((a)))
 650 #define ALCdevice_Unlock(a)              ((a)->Funcs->Unlock((a)))
 651 #define ALCdevice_GetLatency(a)          ((a)->Funcs->GetLatency((a)))
 652
 653 // Frequency was requested by the app or config file
 654 #define DEVICE_FREQUENCY_REQUEST                 (1<<1)
 655 // Channel configuration was requested by the config file
 656 #define DEVICE_CHANNELS_REQUEST                  (1<<2)
 657 // Sample type was requested by the config file
 658 #define DEVICE_SAMPLE_TYPE_REQUEST               (1<<3)
 659
 660 // Stereo sources cover 120-degree angles around +/-90
 661 #define DEVICE_WIDE_STEREO                       (1<<16)
 662
 663 // Specifies if the device is currently running
 664 #define DEVICE_RUNNING                           (1<<31)
 665
 666 #define LookupBuffer(m, k) ((struct ALbuffer*)LookupUIntMapKey(&(m)->BufferMap, (k)))
 667 #define LookupEffect(m, k) ((struct ALeffect*)LookupUIntMapKey(&(m)->EffectMap, (k)))
 668 #define LookupFilter(m, k) ((struct ALfilter*)LookupUIntMapKey(&(m)->FilterMap, (k)))
 669 #define RemoveBuffer(m, k) ((struct ALbuffer*)RemoveUIntMapKey(&(m)->BufferMap, (k)))
 670 #define RemoveEffect(m, k) ((struct ALeffect*)RemoveUIntMapKey(&(m)->EffectMap, (k)))
 671 #define RemoveFilter(m, k) ((struct ALfilter*)RemoveUIntMapKey(&(m)->FilterMap, (k)))
 672
 673
 674 struct ALCcontext_struct
 675 {
 676     volatile RefCount ref;
 677
 678     ALlistener Listener;
 679
 680     UIntMap SourceMap;
 681     UIntMap EffectSlotMap;
 682
 683     ALenum LastError;
 684
 685     volatile ALenum UpdateSources;
 686
 687     volatile enum DistanceModel DistanceModel;
 688     volatile ALboolean SourceDistanceModel;
 689
 690     volatile ALfloat DopplerFactor;
 691     volatile ALfloat DopplerVelocity;
 692     volatile ALfloat SpeedOfSound;
 693     volatile ALenum  DeferUpdates;
 694
 695     struct ALsource **ActiveSources;
 696     ALsizei           ActiveSourceCount;
 697     ALsizei           MaxActiveSources;
 698
 699     struct ALeffectslot **ActiveEffectSlots;
 700     ALsizei               ActiveEffectSlotCount;
 701     ALsizei               MaxActiveEffectSlots;
 702
 703     ALCdevice  *Device;
 704     const ALCchar *ExtensionList;
 705
 706     ALCcontext *volatile next;
 707 };
 708
 709 #define LookupSource(m, k) ((struct ALsource*)LookupUIntMapKey(&(m)->SourceMap, (k)))
 710 #define LookupEffectSlot(m, k) ((struct ALeffectslot*)LookupUIntMapKey(&(m)->EffectSlotMap, (k)))
 711 #define RemoveSource(m, k) ((struct ALsource*)RemoveUIntMapKey(&(m)->SourceMap, (k)))
 712 #define RemoveEffectSlot(m, k) ((struct ALeffectslot*)RemoveUIntMapKey(&(m)->EffectSlotMap, (k)))
 713
 714 ALCcontext *GetContextRef(void);
 715
 716 void ALCcontext_IncRef(ALCcontext *context);
 717 void ALCcontext_DecRef(ALCcontext *context);
 718
 719 void AppendAllDevicesList(const ALCchar *name);
 720 void AppendCaptureDeviceList(const ALCchar *name);
 721
 722 void ALCdevice_LockDefault(ALCdevice *device);
 723 void ALCdevice_UnlockDefault(ALCdevice *device);
 724 ALint64 ALCdevice_GetLatencyDefault(ALCdevice *device);
 725
 726 static __inline void LockContext(ALCcontext *context)
 727 { ALCdevice_Lock(context->Device); }
 728 static __inline void UnlockContext(ALCcontext *context)
 729 { ALCdevice_Unlock(context->Device); }
 730
 731
 732 void *al_malloc(size_t alignment, size_t size);
 733 void *al_calloc(size_t alignment, size_t size);
 734 void al_free(void *ptr);
 735
 736 int SetMixerFPUMode(void);
 737 void RestoreFPUMode(int state);
 738
 739 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
 740 ALuint StopThread(ALvoid *thread);
 741
 742 typedef struct RingBuffer RingBuffer;
 743 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 744 void DestroyRingBuffer(RingBuffer *ring);
 745 ALsizei RingBufferSize(RingBuffer *ring);
 746 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 747 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 748
 749 void ReadALConfig(void);
 750 void FreeALConfig(void);
 751 int ConfigValueExists(const char *blockName, const char *keyName);
 752 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
 753 int GetConfigValueBool(const char *blockName, const char *keyName, int def);
 754 int ConfigValueStr(const char *blockName, const char *keyName, const char **ret);
 755 int ConfigValueInt(const char *blockName, const char *keyName, int *ret);
 756 int ConfigValueUInt(const char *blockName, const char *keyName, unsigned int *ret);
 757 int ConfigValueFloat(const char *blockName, const char *keyName, float *ret);
 758
 759 void SetRTPriority(void);
 760
 761 void SetDefaultChannelOrder(ALCdevice *device);
 762 void SetDefaultWFXChannelOrder(ALCdevice *device);
 763
 764 const ALCchar *DevFmtTypeString(enum DevFmtType type);
 765 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans);
 766
 767 #define HRIR_BITS        (7)
 768 #define HRIR_LENGTH      (1<<HRIR_BITS)
 769 #define HRIR_MASK        (HRIR_LENGTH-1)
 770 #define HRTFDELAY_BITS    (20)
 771 #define HRTFDELAY_FRACONE (1<<HRTFDELAY_BITS)
 772 #define HRTFDELAY_MASK    (HRTFDELAY_FRACONE-1)
 773 const struct Hrtf *GetHrtf(ALCdevice *device);
 774 void FreeHrtfs(void);
 775 ALuint GetHrtfIrSize (const struct Hrtf *Hrtf);
 776 ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3]);
 777 void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays);
 778 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);
 779
 780 void al_print(const char *func, const char *fmt, ...) PRINTF_STYLE(2,3);
 781 #define AL_PRINT(...) al_print(__FUNCTION__, __VA_ARGS__)
 782
 783 extern FILE *LogFile;
 784 enum LogLevel {
 785     NoLog,
 786     LogError,
 787     LogWarning,
 788     LogTrace,
 789     LogRef
 790 };
 791 extern enum LogLevel LogLevel;
 792
 793 #define TRACEREF(...) do {                                                    \
 794     if(LogLevel >= LogRef)                                                    \
 795         AL_PRINT(__VA_ARGS__);                                                \
 796 } while(0)
 797
 798 #define TRACE(...) do {                                                       \
 799     if(LogLevel >= LogTrace)                                                  \
 800         AL_PRINT(__VA_ARGS__);                                                \
 801 } while(0)
 802
 803 #define WARN(...) do {                                                        \
 804     if(LogLevel >= LogWarning)                                                \
 805         AL_PRINT(__VA_ARGS__);                                                \
 806 } while(0)
 807
 808 #define ERR(...) do {                                                         \
 809     if(LogLevel >= LogError)                                                  \
 810         AL_PRINT(__VA_ARGS__);                                                \
 811 } while(0)
 812
 813
 814 extern ALint RTPrioLevel;
 815
 816
 817 extern ALuint CPUCapFlags;
 818 enum {
 819     CPU_CAP_SSE    = 1<<0,
 820     CPU_CAP_NEON   = 1<<1,
 821 };
 822
 823 void FillCPUCaps(ALuint capfilter);
 824
 825
 826 /**
 827  * Starts a try block. Must not be nested within another try block within the
 828  * same function.
 829  */
 830 #define al_try do {                                                           \
 831     int _al_err=0;                                                            \
 832 _al_try_label:                                                                \
 833     if(_al_err == 0)
 834 /**
 835  * After a try or another catch block, runs the next block if the given value
 836  * was thrown.
 837  */
 838 #define al_catch(val) else if(_al_err == (val))
 839 /**
 840  * After a try or catch block, runs the next block for any value thrown and not
 841  * caught.
 842  */
 843 #define al_catchany() else
 844 /** Marks the end of the final catch (or the try) block. */
 845 #define al_endtry } while(0)
 846
 847 /**
 848  * The given integer value is "thrown" so as to be caught by a catch block.
 849  * Must be called in a try block within the same function. The value must not
 850  * be 0.
 851  */
 852 #define al_throw(e) do {                                                      \
 853     _al_err = (e);                                                            \
 854     assert(_al_err != 0);                                                     \
 855     goto _al_try_label;                                                       \
 856 } while(0)
 857 /** Sets an AL error on the given context, before throwing the error code. */
 858 #define al_throwerr(ctx, err) do {                                            \
 859     alSetError((ctx), (err));                                                 \
 860     al_throw((err));                                                          \
 861 } while(0)
 862
 863 /**
 864  * Throws an AL_INVALID_VALUE error with the given ctx if the given condition
 865  * is false.
 866  */
 867 #define CHECK_VALUE(ctx, cond) do {                                           \
 868     if(!(cond))                                                               \
 869         al_throwerr((ctx), AL_INVALID_VALUE);                                 \
 870 } while(0)
 871
 872 #ifdef __cplusplus
 873 }
 874 #endif
 875
 876 #endif