Mercurial > audio-send

comparison OpenAL32/Include/alMain.h @ 0:f9476ff7637e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial forking of open-al to create multiple listeners
author Robert McIntyre <rlm@mit.edu>
date Tue, 25 Oct 2011 13:02:31 -0700
parents
children 96298d83959c
comparison
equal deleted inserted replaced
-1:000000000000 0:f9476ff7637e
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 #ifdef _WIN32
164
165 #ifndef _WIN32_WINNT
166 #define _WIN32_WINNT 0x0500
167 #endif
168 #include <windows.h>
169
170 typedef DWORD tls_type;
171 #define tls_create(x) (*(x) = TlsAlloc())
172 #define tls_delete(x) TlsFree((x))
173 #define tls_get(x) TlsGetValue((x))
174 #define tls_set(x, a) TlsSetValue((x), (a))
175
176 #define HAVE_DYNLOAD 1
177 void *LoadLib(const char *name);
178 void CloseLib(void *handle);
179 void *GetSymbol(void *handle, const char *name);
180
181 typedef LONG pthread_once_t;
182 #define PTHREAD_ONCE_INIT 0
183 void pthread_once(pthread_once_t *once, void (*callback)(void));
184
185 #else
186
187 #include <unistd.h>
188 #include <assert.h>
189 #include <pthread.h>
190 #ifdef HAVE_PTHREAD_NP_H
191 #include <pthread_np.h>
192 #endif
193 #include <sys/time.h>
194 #include <time.h>
195 #include <errno.h>
196
197 #define IsBadWritePtr(a,b) ((a) == NULL && (b) != 0)
198
199 typedef pthread_key_t tls_type;
200 #define tls_create(x) pthread_key_create((x), NULL)
201 #define tls_delete(x) pthread_key_delete((x))
202 #define tls_get(x) pthread_getspecific((x))
203 #define tls_set(x, a) pthread_setspecific((x), (a))
204
205 typedef pthread_mutex_t CRITICAL_SECTION;
206 void InitializeCriticalSection(CRITICAL_SECTION *cs);
207 void DeleteCriticalSection(CRITICAL_SECTION *cs);
208 void EnterCriticalSection(CRITICAL_SECTION *cs);
209 void LeaveCriticalSection(CRITICAL_SECTION *cs);
210
211 ALuint timeGetTime(void);
212
213 static __inline void Sleep(ALuint t)
214 {
215 struct timespec tv, rem;
216 tv.tv_nsec = (t*1000000)%1000000000;
217 tv.tv_sec = t/1000;
218
219 while(nanosleep(&tv, &rem) == -1 && errno == EINTR)
220 tv = rem;
221 }
222
223 #if defined(HAVE_DLFCN_H)
224 #define HAVE_DYNLOAD 1
225 void *LoadLib(const char *name);
226 void CloseLib(void *handle);
227 void *GetSymbol(void *handle, const char *name);
228 #endif
229
230 #endif
231
232 #include "alListener.h"
233 #include "alu.h"
234
235 #ifdef __cplusplus
236 extern "C" {
237 #endif
238
239
240 #define DEFAULT_OUTPUT_RATE (44100)
241
242 #define SPEEDOFSOUNDMETRESPERSEC (343.3f)
243 #define AIRABSORBGAINHF (0.99426) /* -0.05dB */
244
245 #define LOWPASSFREQCUTOFF (5000)
246
247
248 // Find the next power-of-2 for non-power-of-2 numbers.
249 static __inline ALuint NextPowerOf2(ALuint value)
250 {
251 ALuint powerOf2 = 1;
252
253 if(value)
254 {
255 value--;
256 while(value)
257 {
258 value >>= 1;
259 powerOf2 <<= 1;
260 }
261 }
262 return powerOf2;
263 }
264
265
266 enum DevProbe {
267 DEVICE_PROBE,
268 ALL_DEVICE_PROBE,
269 CAPTURE_DEVICE_PROBE
270 };
271
272 typedef struct {
273 ALCboolean (*OpenPlayback)(ALCdevice*, const ALCchar*);
274 void (*ClosePlayback)(ALCdevice*);
275 ALCboolean (*ResetPlayback)(ALCdevice*);
276 void (*StopPlayback)(ALCdevice*);
277
278 ALCboolean (*OpenCapture)(ALCdevice*, const ALCchar*);
279 void (*CloseCapture)(ALCdevice*);
280 void (*StartCapture)(ALCdevice*);
281 void (*StopCapture)(ALCdevice*);
282 void (*CaptureSamples)(ALCdevice*, void*, ALCuint);
283 ALCuint (*AvailableSamples)(ALCdevice*);
284 } BackendFuncs;
285
286 struct BackendInfo {
287 const char *name;
288 ALCboolean (*Init)(BackendFuncs*);
289 void (*Deinit)(void);
290 void (*Probe)(enum DevProbe);
291 BackendFuncs Funcs;
292 };
293
294 ALCboolean alc_alsa_init(BackendFuncs *func_list);
295 void alc_alsa_deinit(void);
296 void alc_alsa_probe(enum DevProbe type);
297 ALCboolean alc_oss_init(BackendFuncs *func_list);
298 void alc_oss_deinit(void);
299 void alc_oss_probe(enum DevProbe type);
300 ALCboolean alc_solaris_init(BackendFuncs *func_list);
301 void alc_solaris_deinit(void);
302 void alc_solaris_probe(enum DevProbe type);
303 ALCboolean alc_sndio_init(BackendFuncs *func_list);
304 void alc_sndio_deinit(void);
305 void alc_sndio_probe(enum DevProbe type);
306 ALCboolean alcMMDevApiInit(BackendFuncs *func_list);
307 void alcMMDevApiDeinit(void);
308 void alcMMDevApiProbe(enum DevProbe type);
309 ALCboolean alcDSoundInit(BackendFuncs *func_list);
310 void alcDSoundDeinit(void);
311 void alcDSoundProbe(enum DevProbe type);
312 ALCboolean alcWinMMInit(BackendFuncs *FuncList);
313 void alcWinMMDeinit(void);
314 void alcWinMMProbe(enum DevProbe type);
315 ALCboolean alc_pa_init(BackendFuncs *func_list);
316 void alc_pa_deinit(void);
317 void alc_pa_probe(enum DevProbe type);
318 ALCboolean alc_wave_init(BackendFuncs *func_list);
319 void alc_wave_deinit(void);
320 void alc_wave_probe(enum DevProbe type);
321 ALCboolean alc_pulse_init(BackendFuncs *func_list);
322 void alc_pulse_deinit(void);
323 void alc_pulse_probe(enum DevProbe type);
324 ALCboolean alc_ca_init(BackendFuncs *func_list);
325 void alc_ca_deinit(void);
326 void alc_ca_probe(enum DevProbe type);
327 ALCboolean alc_opensl_init(BackendFuncs *func_list);
328 void alc_opensl_deinit(void);
329 void alc_opensl_probe(enum DevProbe type);
330 ALCboolean alc_null_init(BackendFuncs *func_list);
331 void alc_null_deinit(void);
332 void alc_null_probe(enum DevProbe type);
333 ALCboolean alc_loopback_init(BackendFuncs *func_list);
334 void alc_loopback_deinit(void);
335 void alc_loopback_probe(enum DevProbe type);
336
337 //RLM: aurellem send device insertion
338 ALCboolean alc_send_init(BackendFuncs *func_list);
339 void alc_send_deinit(void);
340 void alc_send_probe(enum DevProbe type);
341
342
343 typedef struct UIntMap {
344 struct {
345 ALuint key;
346 ALvoid *value;
347 } *array;
348 ALsizei size;
349 ALsizei maxsize;
350 } UIntMap;
351
352 void InitUIntMap(UIntMap *map);
353 void ResetUIntMap(UIntMap *map);
354 ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value);
355 void RemoveUIntMapKey(UIntMap *map, ALuint key);
356 ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key);
357
358 /* Device formats */
359 enum DevFmtType {
360 DevFmtByte = AL_BYTE,
361 DevFmtUByte = AL_UNSIGNED_BYTE,
362 DevFmtShort = AL_SHORT,
363 DevFmtUShort = AL_UNSIGNED_SHORT,
364 DevFmtFloat = AL_FLOAT
365 };
366 enum DevFmtChannels {
367 DevFmtMono = AL_MONO,
368 DevFmtStereo = AL_STEREO,
369 DevFmtQuad = AL_QUAD,
370 DevFmtX51 = AL_5POINT1,
371 DevFmtX61 = AL_6POINT1,
372 DevFmtX71 = AL_7POINT1,
373
374 /* Similar to 5.1, except using the side channels instead of back */
375 DevFmtX51Side = 0x80000000 | AL_5POINT1
376 };
377
378 ALuint BytesFromDevFmt(enum DevFmtType type);
379 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans);
380 static __inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans,
381 enum DevFmtType type)
382 {
383 return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
384 }
385
386
387 extern const struct EffectList {
388 const char *name;
389 int type;
390 const char *ename;
391 ALenum val;
392 } EffectList[];
393
394
395 struct ALCdevice_struct
396 {
397 ALCboolean Connected;
398 ALboolean IsCaptureDevice;
399 ALboolean IsLoopbackDevice;
400
401 CRITICAL_SECTION Mutex;
402
403 ALuint Frequency;
404 ALuint UpdateSize;
405 ALuint NumUpdates;
406 enum DevFmtChannels FmtChans;
407 enum DevFmtType FmtType;
408
409 ALCchar *szDeviceName;
410
411 ALCenum LastError;
412
413 // Maximum number of sources that can be created
414 ALuint MaxNoOfSources;
415 // Maximum number of slots that can be created
416 ALuint AuxiliaryEffectSlotMax;
417
418 ALCuint NumMonoSources;
419 ALCuint NumStereoSources;
420 ALuint NumAuxSends;
421
422 // Map of Buffers for this device
423 UIntMap BufferMap;
424
425 // Map of Effects for this device
426 UIntMap EffectMap;
427
428 // Map of Filters for this device
429 UIntMap FilterMap;
430
431 // Stereo-to-binaural filter
432 struct bs2b *Bs2b;
433 ALCint Bs2bLevel;
434
435 // Device flags
436 ALuint Flags;
437
438 // Dry path buffer mix
439 ALfloat DryBuffer[BUFFERSIZE][MAXCHANNELS];
440
441 enum Channel DevChannels[MAXCHANNELS];
442
443 enum Channel Speaker2Chan[MAXCHANNELS];
444 ALfloat PanningLUT[LUT_NUM][MAXCHANNELS];
445 ALuint NumChan;
446
447 ALfloat ClickRemoval[MAXCHANNELS];
448 ALfloat PendingClicks[MAXCHANNELS];
449
450 // Contexts created on this device
451 ALCcontext **Contexts;
452 ALuint NumContexts;
453
454 BackendFuncs *Funcs;
455 void *ExtraData; // For the backend's use
456
457 ALCdevice *next;
458 };
459
460 #define ALCdevice_OpenPlayback(a,b) ((a)->Funcs->OpenPlayback((a), (b)))
461 #define ALCdevice_ClosePlayback(a) ((a)->Funcs->ClosePlayback((a)))
462 #define ALCdevice_ResetPlayback(a) ((a)->Funcs->ResetPlayback((a)))
463 #define ALCdevice_StopPlayback(a) ((a)->Funcs->StopPlayback((a)))
464 #define ALCdevice_OpenCapture(a,b) ((a)->Funcs->OpenCapture((a), (b)))
465 #define ALCdevice_CloseCapture(a) ((a)->Funcs->CloseCapture((a)))
466 #define ALCdevice_StartCapture(a) ((a)->Funcs->StartCapture((a)))
467 #define ALCdevice_StopCapture(a) ((a)->Funcs->StopCapture((a)))
468 #define ALCdevice_CaptureSamples(a,b,c) ((a)->Funcs->CaptureSamples((a), (b), (c)))
469 #define ALCdevice_AvailableSamples(a) ((a)->Funcs->AvailableSamples((a)))
470
471 // Duplicate stereo sources on the side/rear channels
472 #define DEVICE_DUPLICATE_STEREO (1<<0)
473 // Use HRTF filters for mixing sounds
474 #define DEVICE_USE_HRTF (1<<1)
475 // Frequency was requested by the app or config file
476 #define DEVICE_FREQUENCY_REQUEST (1<<2)
477 // Channel configuration was requested by the config file
478 #define DEVICE_CHANNELS_REQUEST (1<<3)
479
480 // Specifies if the device is currently running
481 #define DEVICE_RUNNING (1<<31)
482
483 struct ALCcontext_struct
484 {
485 ALlistener Listener;
486
487 UIntMap SourceMap;
488 UIntMap EffectSlotMap;
489
490 ALenum LastError;
491
492 ALboolean UpdateSources;
493
494 enum DistanceModel DistanceModel;
495 ALboolean SourceDistanceModel;
496
497 ALfloat DopplerFactor;
498 ALfloat DopplerVelocity;
499 ALfloat flSpeedOfSound;
500 ALboolean DeferUpdates;
501
502 struct ALsource **ActiveSources;
503 ALsizei ActiveSourceCount;
504 ALsizei MaxActiveSources;
505
506 ALCdevice *Device;
507 const ALCchar *ExtensionList;
508
509 ALCcontext *next;
510 };
511
512 void AppendDeviceList(const ALCchar *name);
513 void AppendAllDeviceList(const ALCchar *name);
514 void AppendCaptureDeviceList(const ALCchar *name);
515
516 ALCvoid alcSetError(ALCdevice *device, ALenum errorCode);
517
518 ALCvoid LockDevice(ALCdevice *device);
519 ALCvoid UnlockDevice(ALCdevice *device);
520 ALCvoid LockContext(ALCcontext *context);
521 ALCvoid UnlockContext(ALCcontext *context);
522
523 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
524 ALuint StopThread(ALvoid *thread);
525
526 ALCcontext *GetLockedContext(void);
527
528 typedef struct RingBuffer RingBuffer;
529 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
530 void DestroyRingBuffer(RingBuffer *ring);
531 ALsizei RingBufferSize(RingBuffer *ring);
532 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
533 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
534
535 void ReadALConfig(void);
536 void FreeALConfig(void);
537 int ConfigValueExists(const char *blockName, const char *keyName);
538 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
539 int GetConfigValueInt(const char *blockName, const char *keyName, int def);
540 float GetConfigValueFloat(const char *blockName, const char *keyName, float def);
541 int GetConfigValueBool(const char *blockName, const char *keyName, int def);
542
543 void SetRTPriority(void);
544
545 void SetDefaultChannelOrder(ALCdevice *device);
546 void SetDefaultWFXChannelOrder(ALCdevice *device);
547
548 const ALCchar *DevFmtTypeString(enum DevFmtType type);
549 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans);
550
551 #define HRIR_BITS (5)
552 #define HRIR_LENGTH (1<<HRIR_BITS)
553 #define HRIR_MASK (HRIR_LENGTH-1)
554 void InitHrtf(void);
555 ALCboolean IsHrtfCompatible(ALCdevice *device);
556 ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3]);
557 void GetLerpedHrtfCoeffs(ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays);
558 ALuint GetMovingHrtfCoeffs(ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat delta, ALint counter, ALfloat (*coeffs)[2], ALuint *delays, ALfloat (*coeffStep)[2], ALint *delayStep);
559
560 void al_print(const char *fname, unsigned int line, const char *fmt, ...)
561 PRINTF_STYLE(3,4);
562 #define AL_PRINT(...) al_print(__FILE__, __LINE__, __VA_ARGS__)
563
564 extern FILE *LogFile;
565 enum LogLevel {
566 NoLog,
567 LogError,
568 LogWarning,
569 LogTrace
570 };
571 extern enum LogLevel LogLevel;
572
573 #define TRACE(...) do { \
574 if(LogLevel >= LogTrace) \
575 AL_PRINT(__VA_ARGS__); \
576 } while(0)
577
578 #define WARN(...) do { \
579 if(LogLevel >= LogWarning) \
580 AL_PRINT(__VA_ARGS__); \
581 } while(0)
582
583 #define ERR(...) do { \
584 if(LogLevel >= LogError) \
585 AL_PRINT(__VA_ARGS__); \
586 } while(0)
587
588
589 extern ALdouble ConeScale;
590 extern ALdouble ZScale;
591
592 extern ALint RTPrioLevel;
593
594 #ifdef __cplusplus
595 }
596 #endif
597
598 #endif