Move a couple macros to more appropriate headers
[openal-soft/openal-hmr.git] / OpenAL32 / Include / alMain.h
blobe68975b126e5044cd6434563c0ff29e94d340231
1 #ifndef AL_MAIN_H
2 #define AL_MAIN_H
4 #include <string.h>
5 #include <stdio.h>
6 #include <stdarg.h>
7 #include <assert.h>
9 #ifdef HAVE_FENV_H
10 #include <fenv.h>
11 #endif
13 #ifdef HAVE_FPU_CONTROL_H
14 #include <fpu_control.h>
15 #endif
17 #include "AL/al.h"
18 #include "AL/alc.h"
19 #include "AL/alext.h"
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
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
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
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
83 typedef ptrdiff_t ALintptrEXT;
84 typedef ptrdiff_t ALsizeiptrEXT;
86 #define MAKEU64(x,y) (((ALuint64)(x)<<32)|(ALuint64)(y))
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
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
103 static const union {
104 ALuint u;
105 ALubyte b[sizeof(ALuint)];
106 } EndianTest = { 1 };
107 #define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
109 #define COUNTOF(x) (sizeof((x))/sizeof((x)[0]))
111 #ifdef _WIN32
113 #include <windows.h>
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);
121 #define HAVE_DYNLOAD 1
122 void *LoadLib(const char *name);
123 void CloseLib(void *handle);
124 void *GetSymbol(void *handle, const char *name);
126 WCHAR *strdupW(const WCHAR *str);
128 typedef LONG pthread_once_t;
129 #define PTHREAD_ONCE_INIT 0
130 void pthread_once(pthread_once_t *once, void (*callback)(void));
132 static __inline int sched_yield(void)
133 { SwitchToThread(); return 0; }
135 #else
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>
144 #define IsBadWritePtr(a,b) ((a) == NULL && (b) != 0)
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);
152 ALuint timeGetTime(void);
153 void Sleep(ALuint t);
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
162 #endif
164 typedef void *volatile XchgPtr;
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); }
173 static __inline int ExchangeInt(volatile int *ptr, int newval)
175 return __sync_lock_test_and_set(ptr, newval);
177 static __inline void *ExchangePtr(XchgPtr *ptr, void *newval)
179 return __sync_lock_test_and_set(ptr, newval);
181 static __inline ALboolean CompExchangeInt(volatile int *ptr, int oldval, int newval)
183 return __sync_bool_compare_and_swap(ptr, oldval, newval);
185 static __inline ALboolean CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
187 return __sync_bool_compare_and_swap(ptr, oldval, newval);
190 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
192 static __inline int xaddl(volatile int *dest, int incr)
194 int ret;
195 __asm__ __volatile__("lock; xaddl %0,(%1)"
196 : "=r" (ret)
197 : "r" (dest), "0" (incr)
198 : "memory");
199 return ret;
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; }
208 static __inline int ExchangeInt(volatile int *dest, int newval)
210 int ret;
211 __asm__ __volatile__("lock; xchgl %0,(%1)"
212 : "=r" (ret)
213 : "r" (dest), "0" (newval)
214 : "memory");
215 return ret;
218 static __inline ALboolean CompExchangeInt(volatile int *dest, int oldval, int newval)
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;
228 static __inline void *ExchangePtr(XchgPtr *dest, void *newval)
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"
241 return ret;
244 static __inline ALboolean CompExchangePtr(XchgPtr *dest, void *oldval, void *newval)
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"
257 return ret == oldval;
260 #elif defined(_WIN32)
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); }
268 extern ALbyte LONG_size_does_not_match_int[(sizeof(LONG)==sizeof(int))?1:-1];
270 static __inline int ExchangeInt(volatile int *ptr, int newval)
272 union {
273 volatile int *i;
274 volatile LONG *l;
275 } u = { ptr };
276 return InterlockedExchange(u.l, newval);
278 static __inline void *ExchangePtr(XchgPtr *ptr, void *newval)
280 return InterlockedExchangePointer(ptr, newval);
282 static __inline ALboolean CompExchangeInt(volatile int *ptr, int oldval, int newval)
284 union {
285 volatile int *i;
286 volatile LONG *l;
287 } u = { ptr };
288 return InterlockedCompareExchange(u.l, newval, oldval) == oldval;
290 static __inline ALboolean CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
292 return InterlockedCompareExchangePointer(ptr, newval, oldval) == oldval;
295 #elif defined(__APPLE__)
297 #include <libkern/OSAtomic.h>
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); }
305 static __inline int ExchangeInt(volatile int *ptr, int newval)
307 /* Really? No regular old atomic swap? */
308 int oldval;
309 do {
310 oldval = *ptr;
311 } while(!OSAtomicCompareAndSwap32Barrier(oldval, newval, ptr));
312 return oldval;
314 static __inline void *ExchangePtr(XchgPtr *ptr, void *newval)
316 void *oldval;
317 do {
318 oldval = *ptr;
319 } while(!OSAtomicCompareAndSwapPtrBarrier(oldval, newval, ptr));
320 return oldval;
322 static __inline ALboolean CompExchangeInt(volatile int *ptr, int oldval, int newval)
324 return OSAtomicCompareAndSwap32Barrier(oldval, newval, ptr);
326 static __inline ALboolean CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
328 return OSAtomicCompareAndSwapPtrBarrier(oldval, newval, ptr);
331 #else
332 #error "No atomic functions available on this platform!"
333 typedef ALuint RefCount;
334 #endif
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;
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);
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;
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);
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); }
379 #include "alListener.h"
381 #ifdef __cplusplus
382 extern "C" {
383 #endif
385 struct Hrtf;
388 #define DEFAULT_OUTPUT_RATE (44100)
389 #define MIN_OUTPUT_RATE (8000)
392 // Find the next power-of-2 for non-power-of-2 numbers.
393 static __inline ALuint NextPowerOf2(ALuint value)
395 ALuint powerOf2 = 1;
397 if(value)
399 value--;
400 while(value)
402 value >>= 1;
403 powerOf2 <<= 1;
406 return powerOf2;
409 /* Fast float-to-int conversion. Assumes the FPU is already in round-to-zero
410 * mode. */
411 static __inline ALint fastf2i(ALfloat f)
413 ALint i;
414 #if defined(_MSC_VER) && defined(_M_IX86)
415 __asm fld f
416 __asm fistp i
417 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
418 __asm__ __volatile__("flds %1\n\t"
419 "fistpl %0\n\t"
420 : "=m" (i)
421 : "m" (f));
422 #else
423 i = (ALint)f;
424 #endif
425 return i;
428 /* Fast float-to-uint conversion. Assumes the FPU is already in round-to-zero
429 * mode. */
430 static __inline ALuint fastf2u(ALfloat f)
431 { return fastf2i(f); }
434 enum DevProbe {
435 ALL_DEVICE_PROBE,
436 CAPTURE_DEVICE_PROBE
439 typedef struct {
440 ALCenum (*OpenPlayback)(ALCdevice*, const ALCchar*);
441 void (*ClosePlayback)(ALCdevice*);
442 ALCboolean (*ResetPlayback)(ALCdevice*);
443 ALCboolean (*StartPlayback)(ALCdevice*);
444 void (*StopPlayback)(ALCdevice*);
446 ALCenum (*OpenCapture)(ALCdevice*, const ALCchar*);
447 void (*CloseCapture)(ALCdevice*);
448 void (*StartCapture)(ALCdevice*);
449 void (*StopCapture)(ALCdevice*);
450 ALCenum (*CaptureSamples)(ALCdevice*, void*, ALCuint);
451 ALCuint (*AvailableSamples)(ALCdevice*);
453 void (*Lock)(ALCdevice*);
454 void (*Unlock)(ALCdevice*);
456 ALint64 (*GetLatency)(ALCdevice*);
457 } BackendFuncs;
459 struct BackendInfo {
460 const char *name;
461 ALCboolean (*Init)(BackendFuncs*);
462 void (*Deinit)(void);
463 void (*Probe)(enum DevProbe);
464 BackendFuncs Funcs;
467 ALCboolean alc_alsa_init(BackendFuncs *func_list);
468 void alc_alsa_deinit(void);
469 void alc_alsa_probe(enum DevProbe type);
470 ALCboolean alc_oss_init(BackendFuncs *func_list);
471 void alc_oss_deinit(void);
472 void alc_oss_probe(enum DevProbe type);
473 ALCboolean alc_solaris_init(BackendFuncs *func_list);
474 void alc_solaris_deinit(void);
475 void alc_solaris_probe(enum DevProbe type);
476 ALCboolean alc_sndio_init(BackendFuncs *func_list);
477 void alc_sndio_deinit(void);
478 void alc_sndio_probe(enum DevProbe type);
479 ALCboolean alcMMDevApiInit(BackendFuncs *func_list);
480 void alcMMDevApiDeinit(void);
481 void alcMMDevApiProbe(enum DevProbe type);
482 ALCboolean alcDSoundInit(BackendFuncs *func_list);
483 void alcDSoundDeinit(void);
484 void alcDSoundProbe(enum DevProbe type);
485 ALCboolean alcWinMMInit(BackendFuncs *FuncList);
486 void alcWinMMDeinit(void);
487 void alcWinMMProbe(enum DevProbe type);
488 ALCboolean alc_pa_init(BackendFuncs *func_list);
489 void alc_pa_deinit(void);
490 void alc_pa_probe(enum DevProbe type);
491 ALCboolean alc_wave_init(BackendFuncs *func_list);
492 void alc_wave_deinit(void);
493 void alc_wave_probe(enum DevProbe type);
494 ALCboolean alc_pulse_init(BackendFuncs *func_list);
495 void alc_pulse_deinit(void);
496 void alc_pulse_probe(enum DevProbe type);
497 ALCboolean alc_ca_init(BackendFuncs *func_list);
498 void alc_ca_deinit(void);
499 void alc_ca_probe(enum DevProbe type);
500 ALCboolean alc_opensl_init(BackendFuncs *func_list);
501 void alc_opensl_deinit(void);
502 void alc_opensl_probe(enum DevProbe type);
503 ALCboolean alc_null_init(BackendFuncs *func_list);
504 void alc_null_deinit(void);
505 void alc_null_probe(enum DevProbe type);
506 ALCboolean alc_loopback_init(BackendFuncs *func_list);
507 void alc_loopback_deinit(void);
508 void alc_loopback_probe(enum DevProbe type);
511 enum DistanceModel {
512 InverseDistanceClamped = AL_INVERSE_DISTANCE_CLAMPED,
513 LinearDistanceClamped = AL_LINEAR_DISTANCE_CLAMPED,
514 ExponentDistanceClamped = AL_EXPONENT_DISTANCE_CLAMPED,
515 InverseDistance = AL_INVERSE_DISTANCE,
516 LinearDistance = AL_LINEAR_DISTANCE,
517 ExponentDistance = AL_EXPONENT_DISTANCE,
518 DisableDistance = AL_NONE,
520 DefaultDistanceModel = InverseDistanceClamped
523 enum Resampler {
524 PointResampler,
525 LinearResampler,
526 CubicResampler,
528 ResamplerMax,
531 enum Channel {
532 FrontLeft = 0,
533 FrontRight,
534 FrontCenter,
535 LFE,
536 BackLeft,
537 BackRight,
538 BackCenter,
539 SideLeft,
540 SideRight,
542 MaxChannels,
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,
556 DevFmtTypeDefault = DevFmtFloat
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,
566 /* Similar to 5.1, except using the side channels instead of back */
567 DevFmtX51Side = 0x80000000,
569 DevFmtChannelsDefault = DevFmtStereo
572 ALuint BytesFromDevFmt(enum DevFmtType type);
573 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans);
574 static __inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans,
575 enum DevFmtType type)
577 return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
581 extern const struct EffectList {
582 const char *name;
583 int type;
584 const char *ename;
585 ALenum val;
586 } EffectList[];
589 enum DeviceType {
590 Playback,
591 Capture,
592 Loopback
596 /* Size for temporary storage of buffer data, in ALfloats. Larger values need
597 * more stack, while smaller values may need more iterations. The value needs
598 * to be a sensible size, however, as it constrains the max stepping value used
599 * for mixing, as well as the maximum number of samples per mixing iteration.
600 * The mixer requires being able to do two samplings per mixing loop. A 16KB
601 * buffer can hold 512 sample frames for a 7.1 float buffer. With the cubic
602 * resampler (which requires 3 padding sample frames), this limits the maximum
603 * step to about 508. This means that buffer_freq*source_pitch cannot exceed
604 * device_freq*508 for an 8-channel 32-bit buffer.
606 #ifndef BUFFERSIZE
607 #define BUFFERSIZE 4096
608 #endif
611 struct ALCdevice_struct
613 volatile RefCount ref;
615 ALCboolean Connected;
616 enum DeviceType Type;
618 CRITICAL_SECTION Mutex;
620 ALuint Frequency;
621 ALuint UpdateSize;
622 ALuint NumUpdates;
623 enum DevFmtChannels FmtChans;
624 enum DevFmtType FmtType;
626 ALCchar *DeviceName;
628 volatile ALCenum LastError;
630 // Maximum number of sources that can be created
631 ALuint MaxNoOfSources;
632 // Maximum number of slots that can be created
633 ALuint AuxiliaryEffectSlotMax;
635 ALCuint NumMonoSources;
636 ALCuint NumStereoSources;
637 ALuint NumAuxSends;
639 // Map of Buffers for this device
640 UIntMap BufferMap;
642 // Map of Effects for this device
643 UIntMap EffectMap;
645 // Map of Filters for this device
646 UIntMap FilterMap;
648 /* HRTF filter tables */
649 const struct Hrtf *Hrtf;
651 // Stereo-to-binaural filter
652 struct bs2b *Bs2b;
653 ALCint Bs2bLevel;
655 // Device flags
656 ALuint Flags;
658 enum Channel DevChannels[MaxChannels];
660 enum Channel Speaker2Chan[MaxChannels];
661 ALfloat SpeakerAngle[MaxChannels];
662 ALuint NumChan;
664 // Dry path buffer mix
665 ALIGN(16) ALfloat DryBuffer[MaxChannels][BUFFERSIZE];
667 ALIGN(16) ALfloat ClickRemoval[MaxChannels];
668 ALIGN(16) ALfloat PendingClicks[MaxChannels];
670 /* Default effect slot */
671 struct ALeffectslot *DefaultSlot;
673 // Contexts created on this device
674 ALCcontext *volatile ContextList;
676 BackendFuncs *Funcs;
677 void *ExtraData; // For the backend's use
679 ALCdevice *volatile next;
682 #define ALCdevice_OpenPlayback(a,b) ((a)->Funcs->OpenPlayback((a), (b)))
683 #define ALCdevice_ClosePlayback(a) ((a)->Funcs->ClosePlayback((a)))
684 #define ALCdevice_ResetPlayback(a) ((a)->Funcs->ResetPlayback((a)))
685 #define ALCdevice_StartPlayback(a) ((a)->Funcs->StartPlayback((a)))
686 #define ALCdevice_StopPlayback(a) ((a)->Funcs->StopPlayback((a)))
687 #define ALCdevice_OpenCapture(a,b) ((a)->Funcs->OpenCapture((a), (b)))
688 #define ALCdevice_CloseCapture(a) ((a)->Funcs->CloseCapture((a)))
689 #define ALCdevice_StartCapture(a) ((a)->Funcs->StartCapture((a)))
690 #define ALCdevice_StopCapture(a) ((a)->Funcs->StopCapture((a)))
691 #define ALCdevice_CaptureSamples(a,b,c) ((a)->Funcs->CaptureSamples((a), (b), (c)))
692 #define ALCdevice_AvailableSamples(a) ((a)->Funcs->AvailableSamples((a)))
693 #define ALCdevice_Lock(a) ((a)->Funcs->Lock((a)))
694 #define ALCdevice_Unlock(a) ((a)->Funcs->Unlock((a)))
695 #define ALCdevice_GetLatency(a) ((a)->Funcs->GetLatency((a)))
697 // Frequency was requested by the app or config file
698 #define DEVICE_FREQUENCY_REQUEST (1<<1)
699 // Channel configuration was requested by the config file
700 #define DEVICE_CHANNELS_REQUEST (1<<2)
701 // Sample type was requested by the config file
702 #define DEVICE_SAMPLE_TYPE_REQUEST (1<<3)
704 // Stereo sources cover 120-degree angles around +/-90
705 #define DEVICE_WIDE_STEREO (1<<16)
707 // Specifies if the device is currently running
708 #define DEVICE_RUNNING (1<<31)
710 #define LookupBuffer(m, k) ((struct ALbuffer*)LookupUIntMapKey(&(m)->BufferMap, (k)))
711 #define LookupEffect(m, k) ((struct ALeffect*)LookupUIntMapKey(&(m)->EffectMap, (k)))
712 #define LookupFilter(m, k) ((struct ALfilter*)LookupUIntMapKey(&(m)->FilterMap, (k)))
713 #define RemoveBuffer(m, k) ((struct ALbuffer*)RemoveUIntMapKey(&(m)->BufferMap, (k)))
714 #define RemoveEffect(m, k) ((struct ALeffect*)RemoveUIntMapKey(&(m)->EffectMap, (k)))
715 #define RemoveFilter(m, k) ((struct ALfilter*)RemoveUIntMapKey(&(m)->FilterMap, (k)))
718 struct ALCcontext_struct
720 volatile RefCount ref;
722 ALlistener Listener;
724 UIntMap SourceMap;
725 UIntMap EffectSlotMap;
727 ALenum LastError;
729 volatile ALenum UpdateSources;
731 volatile enum DistanceModel DistanceModel;
732 volatile ALboolean SourceDistanceModel;
734 volatile ALfloat DopplerFactor;
735 volatile ALfloat DopplerVelocity;
736 volatile ALfloat SpeedOfSound;
737 volatile ALenum DeferUpdates;
739 struct ALsource **ActiveSources;
740 ALsizei ActiveSourceCount;
741 ALsizei MaxActiveSources;
743 struct ALeffectslot **ActiveEffectSlots;
744 ALsizei ActiveEffectSlotCount;
745 ALsizei MaxActiveEffectSlots;
747 ALCdevice *Device;
748 const ALCchar *ExtensionList;
750 ALCcontext *volatile next;
753 #define LookupSource(m, k) ((struct ALsource*)LookupUIntMapKey(&(m)->SourceMap, (k)))
754 #define LookupEffectSlot(m, k) ((struct ALeffectslot*)LookupUIntMapKey(&(m)->EffectSlotMap, (k)))
755 #define RemoveSource(m, k) ((struct ALsource*)RemoveUIntMapKey(&(m)->SourceMap, (k)))
756 #define RemoveEffectSlot(m, k) ((struct ALeffectslot*)RemoveUIntMapKey(&(m)->EffectSlotMap, (k)))
758 ALCcontext *GetContextRef(void);
760 void ALCcontext_IncRef(ALCcontext *context);
761 void ALCcontext_DecRef(ALCcontext *context);
763 void AppendAllDevicesList(const ALCchar *name);
764 void AppendCaptureDeviceList(const ALCchar *name);
766 void ALCdevice_LockDefault(ALCdevice *device);
767 void ALCdevice_UnlockDefault(ALCdevice *device);
768 ALint64 ALCdevice_GetLatencyDefault(ALCdevice *device);
770 static __inline void LockContext(ALCcontext *context)
771 { ALCdevice_Lock(context->Device); }
772 static __inline void UnlockContext(ALCcontext *context)
773 { ALCdevice_Unlock(context->Device); }
776 void *al_malloc(size_t alignment, size_t size);
777 void *al_calloc(size_t alignment, size_t size);
778 void al_free(void *ptr);
780 int SetMixerFPUMode(void);
781 void RestoreFPUMode(int state);
783 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
784 ALuint StopThread(ALvoid *thread);
786 typedef struct RingBuffer RingBuffer;
787 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
788 void DestroyRingBuffer(RingBuffer *ring);
789 ALsizei RingBufferSize(RingBuffer *ring);
790 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
791 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
793 void ReadALConfig(void);
794 void FreeALConfig(void);
795 int ConfigValueExists(const char *blockName, const char *keyName);
796 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
797 int GetConfigValueBool(const char *blockName, const char *keyName, int def);
798 int ConfigValueStr(const char *blockName, const char *keyName, const char **ret);
799 int ConfigValueInt(const char *blockName, const char *keyName, int *ret);
800 int ConfigValueUInt(const char *blockName, const char *keyName, unsigned int *ret);
801 int ConfigValueFloat(const char *blockName, const char *keyName, float *ret);
803 void SetRTPriority(void);
805 void SetDefaultChannelOrder(ALCdevice *device);
806 void SetDefaultWFXChannelOrder(ALCdevice *device);
808 const ALCchar *DevFmtTypeString(enum DevFmtType type);
809 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans);
811 #define HRIR_BITS (7)
812 #define HRIR_LENGTH (1<<HRIR_BITS)
813 #define HRIR_MASK (HRIR_LENGTH-1)
814 #define HRTFDELAY_BITS (20)
815 #define HRTFDELAY_FRACONE (1<<HRTFDELAY_BITS)
816 #define HRTFDELAY_MASK (HRTFDELAY_FRACONE-1)
817 const struct Hrtf *GetHrtf(ALCdevice *device);
818 void FreeHrtfs(void);
819 ALuint GetHrtfIrSize (const struct Hrtf *Hrtf);
820 ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3]);
821 void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays);
822 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);
824 void al_print(const char *func, const char *fmt, ...) PRINTF_STYLE(2,3);
825 #define AL_PRINT(...) al_print(__FUNCTION__, __VA_ARGS__)
827 extern FILE *LogFile;
828 enum LogLevel {
829 NoLog,
830 LogError,
831 LogWarning,
832 LogTrace,
833 LogRef
835 extern enum LogLevel LogLevel;
837 #define TRACEREF(...) do { \
838 if(LogLevel >= LogRef) \
839 AL_PRINT(__VA_ARGS__); \
840 } while(0)
842 #define TRACE(...) do { \
843 if(LogLevel >= LogTrace) \
844 AL_PRINT(__VA_ARGS__); \
845 } while(0)
847 #define WARN(...) do { \
848 if(LogLevel >= LogWarning) \
849 AL_PRINT(__VA_ARGS__); \
850 } while(0)
852 #define ERR(...) do { \
853 if(LogLevel >= LogError) \
854 AL_PRINT(__VA_ARGS__); \
855 } while(0)
858 extern ALint RTPrioLevel;
861 extern ALuint CPUCapFlags;
862 enum {
863 CPU_CAP_SSE = 1<<0,
864 CPU_CAP_NEON = 1<<1,
867 void FillCPUCaps(ALuint capfilter);
871 * Starts a try block. Must not be nested within another try block within the
872 * same function.
874 #define al_try do { \
875 int _al_err=0; \
876 _al_try_label: \
877 if(_al_err == 0)
879 * After a try or another catch block, runs the next block if the given value
880 * was thrown.
882 #define al_catch(val) else if(_al_err == (val))
884 * After a try or catch block, runs the next block for any value thrown and not
885 * caught.
887 #define al_catchany() else
888 /** Marks the end of the final catch (or the try) block. */
889 #define al_endtry } while(0)
892 * The given integer value is "thrown" so as to be caught by a catch block.
893 * Must be called in a try block within the same function. The value must not
894 * be 0.
896 #define al_throw(e) do { \
897 _al_err = (e); \
898 assert(_al_err != 0); \
899 goto _al_try_label; \
900 } while(0)
901 /** Sets an AL error on the given context, before throwing the error code. */
902 #define al_throwerr(ctx, err) do { \
903 alSetError((ctx), (err)); \
904 al_throw((err)); \
905 } while(0)
908 * Throws an AL_INVALID_VALUE error with the given ctx if the given condition
909 * is false.
911 #define CHECK_VALUE(ctx, cond) do { \
912 if(!(cond)) \
913 al_throwerr((ctx), AL_INVALID_VALUE); \
914 } while(0)
916 #ifdef __cplusplus
918 #endif
920 #endif