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 #ifdef _WIN32
  17
  18 #ifndef _WIN32_WINNT
  19 #define _WIN32_WINNT 0x0500
  20 #endif
  21 #include <windows.h>
  22
  23 typedef DWORD tls_type;
  24 #define tls_create(x) (*(x) = TlsAlloc())
  25 #define tls_delete(x) TlsFree((x))
  26 #define tls_get(x) TlsGetValue((x))
  27 #define tls_set(x, a) TlsSetValue((x), (a))
  28
  29 #else
  30
  31 #include <unistd.h>
  32 #include <assert.h>
  33 #include <pthread.h>
  34 #ifdef HAVE_PTHREAD_NP_H
  35 #include <pthread_np.h>
  36 #endif
  37 #include <sys/time.h>
  38 #include <time.h>
  39 #include <errno.h>
  40
  41 #define IsBadWritePtr(a,b) (0)
  42
  43 typedef pthread_key_t tls_type;
  44 #define tls_create(x) pthread_key_create((x), NULL)
  45 #define tls_delete(x) pthread_key_delete((x))
  46 #define tls_get(x) pthread_getspecific((x))
  47 #define tls_set(x, a) pthread_setspecific((x), (a))
  48
  49 typedef pthread_mutex_t CRITICAL_SECTION;
  50 static inline void EnterCriticalSection(CRITICAL_SECTION *cs)
  51 {
  52     int ret;
  53     ret = pthread_mutex_lock(cs);
  54     assert(ret == 0);
  55 }
  56 static inline void LeaveCriticalSection(CRITICAL_SECTION *cs)
  57 {
  58     int ret;
  59     ret = pthread_mutex_unlock(cs);
  60     assert(ret == 0);
  61 }
  62 static inline void InitializeCriticalSection(CRITICAL_SECTION *cs)
  63 {
  64     pthread_mutexattr_t attrib;
  65     int ret;
  66
  67     ret = pthread_mutexattr_init(&attrib);
  68     assert(ret == 0);
  69
  70     ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
  71 #ifdef HAVE_PTHREAD_NP_H
  72     if(ret != 0)
  73         ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
  74 #endif
  75     assert(ret == 0);
  76     ret = pthread_mutex_init(cs, &attrib);
  77     assert(ret == 0);
  78
  79     pthread_mutexattr_destroy(&attrib);
  80 }
  81
  82 static inline void DeleteCriticalSection(CRITICAL_SECTION *cs)
  83 {
  84     int ret;
  85     ret = pthread_mutex_destroy(cs);
  86     assert(ret == 0);
  87 }
  88
  89 /* NOTE: This wrapper isn't quite accurate as it returns an ALuint, as opposed
  90  * to the expected DWORD. Both are defined as unsigned 32-bit types, however.
  91  * Additionally, Win32 is supposed to measure the time since Windows started,
  92  * as opposed to the actual time. */
  93 static inline ALuint timeGetTime(void)
  94 {
  95     int ret;
  96 #ifdef _POSIX_TIMERS
  97     struct timespec ts;
  98
  99     ret = clock_gettime(CLOCK_REALTIME, &ts);
 100     assert(ret == 0);
 101
 102     return ts.tv_nsec/1000000 + ts.tv_sec*1000;
 103 #else
 104     struct timeval tv;
 105
 106     ret = gettimeofday(&tv, NULL);
 107     assert(ret == 0);
 108
 109     return tv.tv_usec/1000 + tv.tv_sec*1000;
 110 #endif
 111 }
 112
 113 static inline void Sleep(ALuint t)
 114 {
 115     struct timespec tv, rem;
 116     tv.tv_nsec = (t*1000000)%1000000000;
 117     tv.tv_sec = t/1000;
 118
 119     while(nanosleep(&tv, &rem) == -1 && errno == EINTR)
 120         tv = rem;
 121 }
 122 #define min(x,y) (((x)<(y))?(x):(y))
 123 #define max(x,y) (((x)>(y))?(x):(y))
 124 #endif
 125
 126 #include "alListener.h"
 127 #include "alu.h"
 128
 129 #ifdef __cplusplus
 130 extern "C" {
 131 #endif
 132
 133 static __inline void al_print(const char *fname, unsigned int line, const char *fmt, ...)
 134 {
 135     const char *fn;
 136     char str[256];
 137     int i;
 138
 139     fn = strrchr(fname, '/');
 140     if(!fn) fn = strrchr(fname, '\\');;
 141     if(!fn) fn = fname;
 142     else fn += 1;
 143
 144     i = snprintf(str, sizeof(str), "AL lib: %s:%d: ", fn, line);
 145     if(i < (int)sizeof(str) && i > 0)
 146     {
 147         va_list ap;
 148         va_start(ap, fmt);
 149         vsnprintf(str+i, sizeof(str)-i, fmt, ap);
 150         va_end(ap);
 151     }
 152     str[sizeof(str)-1] = 0;
 153
 154     fprintf(stderr, "%s", str);
 155 }
 156 #define AL_PRINT(...) al_print(__FILE__, __LINE__, __VA_ARGS__)
 157
 158
 159 #define SWMIXER_OUTPUT_RATE        44100
 160
 161 #define SPEEDOFSOUNDMETRESPERSEC   (343.3f)
 162 #define AIRABSORBGAINDBHF          (-0.05f)
 163
 164 #define LOWPASSFREQCUTOFF          (5000)
 165
 166
 167 // Find the next power-of-2 for non-power-of-2 numbers.
 168 static __inline ALuint NextPowerOf2(ALuint value)
 169 {
 170     ALuint powerOf2 = 1;
 171
 172     if(value)
 173     {
 174         value--;
 175         while(value)
 176         {
 177             value >>= 1;
 178             powerOf2 <<= 1;
 179         }
 180     }
 181     return powerOf2;
 182 }
 183
 184
 185 typedef struct {
 186     ALCboolean (*OpenPlayback)(ALCdevice*, const ALCchar*);
 187     void (*ClosePlayback)(ALCdevice*);
 188     ALCboolean (*ResetPlayback)(ALCdevice*);
 189     void (*StopPlayback)(ALCdevice*);
 190
 191     ALCboolean (*OpenCapture)(ALCdevice*, const ALCchar*);
 192     void (*CloseCapture)(ALCdevice*);
 193     void (*StartCapture)(ALCdevice*);
 194     void (*StopCapture)(ALCdevice*);
 195     void (*CaptureSamples)(ALCdevice*, void*, ALCuint);
 196     ALCuint (*AvailableSamples)(ALCdevice*);
 197 } BackendFuncs;
 198
 199 enum {
 200     DEVICE_PROBE,
 201     ALL_DEVICE_PROBE,
 202     CAPTURE_DEVICE_PROBE
 203 };
 204
 205 void alc_alsa_init(BackendFuncs *func_list);
 206 void alc_alsa_deinit(void);
 207 void alc_alsa_probe(int type);
 208 void alc_oss_init(BackendFuncs *func_list);
 209 void alc_oss_deinit(void);
 210 void alc_oss_probe(int type);
 211 void alc_solaris_init(BackendFuncs *func_list);
 212 void alc_solaris_deinit(void);
 213 void alc_solarise_probe(int type);
 214 void alcDSoundInit(BackendFuncs *func_list);
 215 void alcDSoundDeinit(void);
 216 void alcDSoundProbe(int type);
 217 void alcWinMMInit(BackendFuncs *FuncList);
 218 void alcWinMMDeinit(void);
 219 void alcWinMMProbe(int type);
 220 void alc_pa_init(BackendFuncs *func_list);
 221 void alc_pa_deinit(void);
 222 void alc_pa_probe(int type);
 223 void alc_wave_init(BackendFuncs *func_list);
 224 void alc_wave_deinit(void);
 225 void alc_wave_probe(int type);
 226 void alc_pulse_init(BackendFuncs *func_list);
 227 void alc_pulse_deinit(void);
 228 void alc_pulse_probe(int type);
 229
 230
 231 struct ALCdevice_struct
 232 {
 233     ALCboolean   Connected;
 234     ALboolean    IsCaptureDevice;
 235
 236     ALuint       Frequency;
 237     ALuint       UpdateSize;
 238     ALuint       NumUpdates;
 239     ALenum       Format;
 240
 241     ALCchar      *szDeviceName;
 242
 243     // Maximum number of sources that can be created
 244     ALuint       MaxNoOfSources;
 245     // Maximum number of slots that can be created
 246     ALuint       AuxiliaryEffectSlotMax;
 247
 248     ALint        lNumMonoSources;
 249     ALint        lNumStereoSources;
 250     ALuint       NumAuxSends;
 251
 252     // Linked List of Buffers for this device
 253     struct ALbuffer *Buffers;
 254     ALuint          BufferCount;
 255
 256     // Linked List of Effects for this device
 257     struct ALeffect *EffectList;
 258     ALuint          EffectCount;
 259
 260     // Linked List of Filters for this device
 261     struct ALfilter *FilterList;
 262     ALuint          FilterCount;
 263
 264     // Linked List of Databuffers for this device
 265     struct ALdatabuffer *Databuffers;
 266     ALuint              DatabufferCount;
 267
 268     // Stereo-to-binaural filter
 269     struct bs2b *Bs2b;
 270     ALCint       Bs2bLevel;
 271
 272     // Dry path buffer mix
 273     float DryBuffer[BUFFERSIZE][OUTPUTCHANNELS];
 274
 275     Channel DevChannels[OUTPUTCHANNELS];
 276
 277     // Contexts created on this device
 278     ALCcontext  **Contexts;
 279     ALuint        NumContexts;
 280
 281     BackendFuncs *Funcs;
 282     void         *ExtraData; // For the backend's use
 283
 284     ALCdevice *next;
 285 };
 286
 287 #define ALCdevice_OpenPlayback(a,b)      ((a)->Funcs->OpenPlayback((a), (b)))
 288 #define ALCdevice_ClosePlayback(a)       ((a)->Funcs->ClosePlayback((a)))
 289 #define ALCdevice_ResetPlayback(a)       ((a)->Funcs->ResetPlayback((a)))
 290 #define ALCdevice_StopPlayback(a)        ((a)->Funcs->StopPlayback((a)))
 291 #define ALCdevice_OpenCapture(a,b)       ((a)->Funcs->OpenCapture((a), (b)))
 292 #define ALCdevice_CloseCapture(a)        ((a)->Funcs->CloseCapture((a)))
 293 #define ALCdevice_StartCapture(a)        ((a)->Funcs->StartCapture((a)))
 294 #define ALCdevice_StopCapture(a)         ((a)->Funcs->StopCapture((a)))
 295 #define ALCdevice_CaptureSamples(a,b,c)  ((a)->Funcs->CaptureSamples((a), (b), (c)))
 296 #define ALCdevice_AvailableSamples(a)    ((a)->Funcs->AvailableSamples((a)))
 297
 298 struct ALCcontext_struct
 299 {
 300     ALlistener  Listener;
 301
 302     struct ALsource *Source;
 303     ALuint           SourceCount;
 304
 305     struct ALeffectslot *AuxiliaryEffectSlot;
 306     ALuint               AuxiliaryEffectSlotCount;
 307
 308     struct ALdatabuffer *SampleSource;
 309     struct ALdatabuffer *SampleSink;
 310
 311     ALenum      LastError;
 312     ALboolean   InUse;
 313
 314     ALenum      DistanceModel;
 315     ALboolean   SourceDistanceModel;
 316
 317     ALfloat     DopplerFactor;
 318     ALfloat     DopplerVelocity;
 319     ALfloat     flSpeedOfSound;
 320
 321     ALfloat     PanningLUT[OUTPUTCHANNELS * LUT_NUM];
 322     ALint       NumChan;
 323
 324     ALfloat     ChannelMatrix[OUTPUTCHANNELS][OUTPUTCHANNELS];
 325
 326     ALCdevice  *Device;
 327     const ALCchar *ExtensionList;
 328
 329     ALCcontext *next;
 330 };
 331
 332 extern ALint RTPrioLevel;
 333
 334 ALCvoid ReleaseALC(ALCvoid);
 335
 336 void AppendDeviceList(const ALCchar *name);
 337 void AppendAllDeviceList(const ALCchar *name);
 338 void AppendCaptureDeviceList(const ALCchar *name);
 339
 340 ALCvoid alcSetError(ALenum errorCode);
 341
 342 ALCvoid SuspendContext(ALCcontext *context);
 343 ALCvoid ProcessContext(ALCcontext *context);
 344
 345 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
 346 ALuint StopThread(ALvoid *thread);
 347
 348 ALCcontext *GetContextSuspended(void);
 349
 350 typedef struct RingBuffer RingBuffer;
 351 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 352 void DestroyRingBuffer(RingBuffer *ring);
 353 ALsizei RingBufferSize(RingBuffer *ring);
 354 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 355 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 356
 357 void ReadALConfig(void);
 358 void FreeALConfig(void);
 359 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
 360 int GetConfigValueInt(const char *blockName, const char *keyName, int def);
 361 float GetConfigValueFloat(const char *blockName, const char *keyName, float def);
 362 int GetConfigValueBool(const char *blockName, const char *keyName, float def);
 363
 364 void EnableRTPrio(ALint level);
 365
 366 ALCboolean  ALCAPIENTRY alcMakeCurrent(ALCcontext *context);
 367 ALCcontext* ALCAPIENTRY alcGetThreadContext(void);
 368
 369 // Sets the default channel order used by most non-WaveFormatEx-based APIs
 370 static __inline void SetDefaultChannelOrder(ALCdevice *device)
 371 {
 372     switch(aluChannelsFromFormat(device->Format))
 373     {
 374     case 1: /* Mono is rendered as stereo; fall-through... */
 375     case 2: device->DevChannels[0] = FRONT_LEFT;
 376             device->DevChannels[1] = FRONT_RIGHT; break;
 377
 378     case 4: device->DevChannels[0] = FRONT_LEFT;
 379             device->DevChannels[1] = FRONT_RIGHT;
 380             device->DevChannels[2] = BACK_LEFT;
 381             device->DevChannels[3] = BACK_RIGHT; break;
 382
 383     case 6: device->DevChannels[0] = FRONT_LEFT;
 384             device->DevChannels[1] = FRONT_RIGHT;
 385             device->DevChannels[2] = BACK_LEFT;
 386             device->DevChannels[3] = BACK_RIGHT;
 387             device->DevChannels[4] = FRONT_CENTER;
 388             device->DevChannels[5] = LFE; break;
 389
 390     case 7: device->DevChannels[0] = FRONT_LEFT;
 391             device->DevChannels[1] = FRONT_RIGHT;
 392             device->DevChannels[2] = FRONT_CENTER;
 393             device->DevChannels[3] = LFE;
 394             device->DevChannels[4] = FRONT_CENTER;
 395             device->DevChannels[5] = SIDE_LEFT;
 396             device->DevChannels[6] = SIDE_RIGHT; break;
 397
 398     case 8: device->DevChannels[0] = FRONT_LEFT;
 399             device->DevChannels[1] = FRONT_RIGHT;
 400             device->DevChannels[2] = BACK_LEFT;
 401             device->DevChannels[3] = BACK_RIGHT;
 402             device->DevChannels[4] = FRONT_CENTER;
 403             device->DevChannels[5] = LFE;
 404             device->DevChannels[6] = SIDE_LEFT;
 405             device->DevChannels[7] = SIDE_RIGHT; break;
 406     }
 407 }
 408 // Sets the default order used by WaveFormatEx
 409 static __inline void SetDefaultWFXChannelOrder(ALCdevice *device)
 410 {
 411     switch(aluChannelsFromFormat(device->Format))
 412     {
 413     case 1: /* Mono is rendered as stereo; fall-through... */
 414     case 2: device->DevChannels[0] = FRONT_LEFT;
 415             device->DevChannels[1] = FRONT_RIGHT; break;
 416
 417     case 4: device->DevChannels[0] = FRONT_LEFT;
 418             device->DevChannels[1] = FRONT_RIGHT;
 419             device->DevChannels[2] = BACK_LEFT;
 420             device->DevChannels[3] = BACK_RIGHT; break;
 421
 422     case 6: device->DevChannels[0] = FRONT_LEFT;
 423             device->DevChannels[1] = FRONT_RIGHT;
 424             device->DevChannels[2] = FRONT_CENTER;
 425             device->DevChannels[3] = LFE;
 426             device->DevChannels[4] = BACK_LEFT;
 427             device->DevChannels[5] = BACK_RIGHT; break;
 428
 429     case 7: device->DevChannels[0] = FRONT_LEFT;
 430             device->DevChannels[1] = FRONT_RIGHT;
 431             device->DevChannels[2] = FRONT_CENTER;
 432             device->DevChannels[3] = LFE;
 433             device->DevChannels[4] = FRONT_CENTER;
 434             device->DevChannels[5] = SIDE_LEFT;
 435             device->DevChannels[6] = SIDE_RIGHT; break;
 436
 437     case 8: device->DevChannels[0] = FRONT_LEFT;
 438             device->DevChannels[1] = FRONT_RIGHT;
 439             device->DevChannels[2] = FRONT_CENTER;
 440             device->DevChannels[3] = LFE;
 441             device->DevChannels[4] = BACK_LEFT;
 442             device->DevChannels[5] = BACK_RIGHT;
 443             device->DevChannels[6] = SIDE_LEFT;
 444             device->DevChannels[7] = SIDE_RIGHT; break;
 445     }
 446 }
 447
 448 #ifdef __cplusplus
 449 }
 450 #endif
 451
 452 #endif