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