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