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 AL_EXT_sample_buffer_object
  17 #define AL_EXT_sample_buffer_object 1
  18 typedef ptrdiff_t ALintptrEXT;
  19 typedef ptrdiff_t ALsizeiptrEXT;
  20 #define AL_SAMPLE_SOURCE_EXT                     0x1040
  21 #define AL_SAMPLE_SINK_EXT                       0x1041
  22 #define AL_READ_ONLY_EXT                         0x1042
  23 #define AL_WRITE_ONLY_EXT                        0x1043
  24 #define AL_READ_WRITE_EXT                        0x1044
  25 #define AL_STREAM_WRITE_EXT                      0x1045
  26 #define AL_STREAM_READ_EXT                       0x1046
  27 #define AL_STREAM_COPY_EXT                       0x1047
  28 #define AL_STATIC_WRITE_EXT                      0x1048
  29 #define AL_STATIC_READ_EXT                       0x1049
  30 #define AL_STATIC_COPY_EXT                       0x104A
  31 #define AL_DYNAMIC_WRITE_EXT                     0x104B
  32 #define AL_DYNAMIC_READ_EXT                      0x104C
  33 #define AL_DYNAMIC_COPY_EXT                      0x104D
  34 typedef ALvoid (AL_APIENTRY*PFNALGENDATABUFFERSEXTPROC)(ALsizei n,ALuint *puiBuffers);
  35 typedef ALvoid (AL_APIENTRY*PFNALDELETEDATABUFFERSEXTPROC)(ALsizei n, const ALuint *puiBuffers);
  36 typedef ALboolean (AL_APIENTRY*PFNALISDATABUFFEREXTPROC)(ALuint uiBuffer);
  37 typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERDATAEXTPROC)(ALuint buffer,const ALvoid *data,ALsizeiptrEXT size,ALenum usage);
  38 typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERSUBDATAEXTPROC)(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, const ALvoid *);
  39 typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERSUBDATAEXTPROC)(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, ALvoid *);
  40 typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERFEXTPROC)(ALuint buffer, ALenum eParam, ALfloat flValue);
  41 typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERFVEXTPROC)(ALuint buffer, ALenum eParam, const ALfloat* flValues);
  42 typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERIEXTPROC)(ALuint buffer, ALenum eParam, ALint lValue);
  43 typedef ALvoid (AL_APIENTRY*PFNALDATABUFFERIVEXTPROC)(ALuint buffer, ALenum eParam, const ALint* plValues);
  44 typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERFEXTPROC)(ALuint buffer, ALenum eParam, ALfloat *pflValue);
  45 typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERFVEXTPROC)(ALuint buffer, ALenum eParam, ALfloat* pflValues);
  46 typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERIEXTPROC)(ALuint buffer, ALenum eParam, ALint *plValue);
  47 typedef ALvoid (AL_APIENTRY*PFNALGETDATABUFFERIVEXTPROC)(ALuint buffer, ALenum eParam, ALint* plValues);
  48 typedef ALvoid (AL_APIENTRY*PFNALSELECTDATABUFFEREXTPROC)(ALenum target, ALuint uiBuffer);
  49 typedef ALvoid* (AL_APIENTRY*PFNALMAPDATABUFFEREXTPROC)(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access);
  50 typedef ALvoid (AL_APIENTRY*PFNALUNMAPDATABUFFEREXTPROC)(ALuint uiBuffer);
  51 #ifdef AL_ALEXT_PROTOTYPES
  52 AL_API ALvoid AL_APIENTRY alGenDatabuffersEXT(ALsizei n,ALuint *puiBuffers);
  53 AL_API ALvoid AL_APIENTRY alDeleteDatabuffersEXT(ALsizei n, const ALuint *puiBuffers);
  54 AL_API ALboolean AL_APIENTRY alIsDatabufferEXT(ALuint uiBuffer);
  55 AL_API ALvoid AL_APIENTRY alDatabufferDataEXT(ALuint buffer,const ALvoid *data,ALsizeiptrEXT size,ALenum usage);
  56 AL_API ALvoid AL_APIENTRY alDatabufferSubDataEXT(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, const ALvoid *data);
  57 AL_API ALvoid AL_APIENTRY alGetDatabufferSubDataEXT(ALuint buffer, ALintptrEXT start, ALsizeiptrEXT length, ALvoid *data);
  58 AL_API ALvoid AL_APIENTRY alDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat flValue);
  59 AL_API ALvoid AL_APIENTRY alDatabufferfvEXT(ALuint buffer, ALenum eParam, const ALfloat* flValues);
  60 AL_API ALvoid AL_APIENTRY alDatabufferiEXT(ALuint buffer, ALenum eParam, ALint lValue);
  61 AL_API ALvoid AL_APIENTRY alDatabufferivEXT(ALuint buffer, ALenum eParam, const ALint* plValues);
  62 AL_API ALvoid AL_APIENTRY alGetDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat *pflValue);
  63 AL_API ALvoid AL_APIENTRY alGetDatabufferfvEXT(ALuint buffer, ALenum eParam, ALfloat* pflValues);
  64 AL_API ALvoid AL_APIENTRY alGetDatabufferiEXT(ALuint buffer, ALenum eParam, ALint *plValue);
  65 AL_API ALvoid AL_APIENTRY alGetDatabufferivEXT(ALuint buffer, ALenum eParam, ALint* plValues);
  66 AL_API ALvoid AL_APIENTRY alSelectDatabufferEXT(ALenum target, ALuint uiBuffer);
  67 AL_API ALvoid* AL_APIENTRY alMapDatabufferEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access);
  68 AL_API ALvoid AL_APIENTRY alUnmapDatabufferEXT(ALuint uiBuffer);
  69 #endif
  70 #endif
  71
  72 #ifndef AL_EXT_loop_points
  73 #define AL_EXT_loop_points 1
  74 #define AL_LOOP_POINTS                           0x2015
  75 #endif
  76
  77
  78 #if defined(HAVE_STDINT_H)
  79 #include <stdint.h>
  80 typedef int64_t ALint64;
  81 typedef uint64_t ALuint64;
  82 #elif defined(HAVE___INT64)
  83 typedef __int64 ALint64;
  84 typedef unsigned __int64 ALuint64;
  85 #elif (SIZEOF_LONG == 8)
  86 typedef long ALint64;
  87 typedef unsigned long ALuint64;
  88 #elif (SIZEOF_LONG_LONG == 8)
  89 typedef long long ALint64;
  90 typedef unsigned long long ALuint64;
  91 #endif
  92
  93 #ifdef HAVE_GCC_FORMAT
  94 #define PRINTF_STYLE(x, y) __attribute__((format(printf, (x), (y))))
  95 #else
  96 #define PRINTF_STYLE(x, y)
  97 #endif
  98
  99 #ifdef _WIN32
 100
 101 #ifndef _WIN32_WINNT
 102 #define _WIN32_WINNT 0x0500
 103 #endif
 104 #include <windows.h>
 105
 106 typedef DWORD tls_type;
 107 #define tls_create(x) (*(x) = TlsAlloc())
 108 #define tls_delete(x) TlsFree((x))
 109 #define tls_get(x) TlsGetValue((x))
 110 #define tls_set(x, a) TlsSetValue((x), (a))
 111
 112 #else
 113
 114 #include <unistd.h>
 115 #include <assert.h>
 116 #include <pthread.h>
 117 #ifdef HAVE_PTHREAD_NP_H
 118 #include <pthread_np.h>
 119 #endif
 120 #include <sys/time.h>
 121 #include <time.h>
 122 #include <errno.h>
 123
 124 #define IsBadWritePtr(a,b) ((a) == NULL && (b) != 0)
 125
 126 typedef pthread_key_t tls_type;
 127 #define tls_create(x) pthread_key_create((x), NULL)
 128 #define tls_delete(x) pthread_key_delete((x))
 129 #define tls_get(x) pthread_getspecific((x))
 130 #define tls_set(x, a) pthread_setspecific((x), (a))
 131
 132 typedef pthread_mutex_t CRITICAL_SECTION;
 133 static __inline void EnterCriticalSection(CRITICAL_SECTION *cs)
 134 {
 135     int ret;
 136     ret = pthread_mutex_lock(cs);
 137     assert(ret == 0);
 138 }
 139 static __inline void LeaveCriticalSection(CRITICAL_SECTION *cs)
 140 {
 141     int ret;
 142     ret = pthread_mutex_unlock(cs);
 143     assert(ret == 0);
 144 }
 145 static __inline void InitializeCriticalSection(CRITICAL_SECTION *cs)
 146 {
 147     pthread_mutexattr_t attrib;
 148     int ret;
 149
 150     ret = pthread_mutexattr_init(&attrib);
 151     assert(ret == 0);
 152
 153     ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
 154 #ifdef HAVE_PTHREAD_NP_H
 155     if(ret != 0)
 156         ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
 157 #endif
 158     assert(ret == 0);
 159     ret = pthread_mutex_init(cs, &attrib);
 160     assert(ret == 0);
 161
 162     pthread_mutexattr_destroy(&attrib);
 163 }
 164
 165 static __inline void DeleteCriticalSection(CRITICAL_SECTION *cs)
 166 {
 167     int ret;
 168     ret = pthread_mutex_destroy(cs);
 169     assert(ret == 0);
 170 }
 171
 172 /* NOTE: This wrapper isn't quite accurate as it returns an ALuint, as opposed
 173  * to the expected DWORD. Both are defined as unsigned 32-bit types, however.
 174  * Additionally, Win32 is supposed to measure the time since Windows started,
 175  * as opposed to the actual time. */
 176 static __inline ALuint timeGetTime(void)
 177 {
 178 #if _POSIX_TIMERS > 0
 179     struct timespec ts;
 180     int ret = -1;
 181
 182 #if defined(_POSIX_MONOTONIC_CLOCK) && (_POSIX_MONOTONIC_CLOCK >= 0)
 183 #if _POSIX_MONOTONIC_CLOCK == 0
 184     static int hasmono = 0;
 185     if(hasmono > 0 || (hasmono == 0 &&
 186                        (hasmono=sysconf(_SC_MONOTONIC_CLOCK)) > 0))
 187 #endif
 188         ret = clock_gettime(CLOCK_MONOTONIC, &ts);
 189 #endif
 190     if(ret != 0)
 191         ret = clock_gettime(CLOCK_REALTIME, &ts);
 192     assert(ret == 0);
 193
 194     return ts.tv_nsec/1000000 + ts.tv_sec*1000;
 195 #else
 196     struct timeval tv;
 197     int ret;
 198
 199     ret = gettimeofday(&tv, NULL);
 200     assert(ret == 0);
 201
 202     return tv.tv_usec/1000 + tv.tv_sec*1000;
 203 #endif
 204 }
 205
 206 static __inline void Sleep(ALuint t)
 207 {
 208     struct timespec tv, rem;
 209     tv.tv_nsec = (t*1000000)%1000000000;
 210     tv.tv_sec = t/1000;
 211
 212     while(nanosleep(&tv, &rem) == -1 && errno == EINTR)
 213         tv = rem;
 214 }
 215 #define min(x,y) (((x)<(y))?(x):(y))
 216 #define max(x,y) (((x)>(y))?(x):(y))
 217 #endif
 218
 219 #include "alListener.h"
 220 #include "alu.h"
 221
 222 #ifdef __cplusplus
 223 extern "C" {
 224 #endif
 225
 226
 227 #define SWMIXER_OUTPUT_RATE        44100
 228
 229 #define SPEEDOFSOUNDMETRESPERSEC   (343.3f)
 230 #define AIRABSORBGAINDBHF          (-0.05f)
 231
 232 #define LOWPASSFREQCUTOFF          (5000)
 233
 234 #define DEFAULT_HEAD_DAMPEN        (0.25f)
 235
 236
 237 // Find the next power-of-2 for non-power-of-2 numbers.
 238 static __inline ALuint NextPowerOf2(ALuint value)
 239 {
 240     ALuint powerOf2 = 1;
 241
 242     if(value)
 243     {
 244         value--;
 245         while(value)
 246         {
 247             value >>= 1;
 248             powerOf2 <<= 1;
 249         }
 250     }
 251     return powerOf2;
 252 }
 253
 254
 255 typedef struct {
 256     ALCboolean (*OpenPlayback)(ALCdevice*, const ALCchar*);
 257     void (*ClosePlayback)(ALCdevice*);
 258     ALCboolean (*ResetPlayback)(ALCdevice*);
 259     void (*StopPlayback)(ALCdevice*);
 260
 261     ALCboolean (*OpenCapture)(ALCdevice*, const ALCchar*);
 262     void (*CloseCapture)(ALCdevice*);
 263     void (*StartCapture)(ALCdevice*);
 264     void (*StopCapture)(ALCdevice*);
 265     void (*CaptureSamples)(ALCdevice*, void*, ALCuint);
 266     ALCuint (*AvailableSamples)(ALCdevice*);
 267 } BackendFuncs;
 268
 269 enum {
 270     DEVICE_PROBE,
 271     ALL_DEVICE_PROBE,
 272     CAPTURE_DEVICE_PROBE
 273 };
 274
 275 void alc_alsa_init(BackendFuncs *func_list);
 276 void alc_alsa_deinit(void);
 277 void alc_alsa_probe(int type);
 278 void alc_oss_init(BackendFuncs *func_list);
 279 void alc_oss_deinit(void);
 280 void alc_oss_probe(int type);
 281 void alc_solaris_init(BackendFuncs *func_list);
 282 void alc_solaris_deinit(void);
 283 void alc_solaris_probe(int type);
 284 void alcDSoundInit(BackendFuncs *func_list);
 285 void alcDSoundDeinit(void);
 286 void alcDSoundProbe(int type);
 287 void alcWinMMInit(BackendFuncs *FuncList);
 288 void alcWinMMDeinit(void);
 289 void alcWinMMProbe(int type);
 290 void alc_pa_init(BackendFuncs *func_list);
 291 void alc_pa_deinit(void);
 292 void alc_pa_probe(int type);
 293 void alc_wave_init(BackendFuncs *func_list);
 294 void alc_wave_deinit(void);
 295 void alc_wave_probe(int type);
 296 void alc_pulse_init(BackendFuncs *func_list);
 297 void alc_pulse_deinit(void);
 298 void alc_pulse_probe(int type);
 299 void alc_null_init(BackendFuncs *func_list);
 300 void alc_null_deinit(void);
 301 void alc_null_probe(int type);
 302
 303
 304 typedef struct UIntMap {
 305     struct {
 306         ALuint key;
 307         ALvoid *value;
 308     } *array;
 309     ALsizei size;
 310     ALsizei maxsize;
 311 } UIntMap;
 312
 313 void InitUIntMap(UIntMap *map);
 314 void ResetUIntMap(UIntMap *map);
 315 ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value);
 316 void RemoveUIntMapKey(UIntMap *map, ALuint key);
 317 ALvoid *LookupUIntMapKey(UIntMap *map, ALuint key);
 318
 319 /* Device formats */
 320 enum DevFmtType {
 321     DevFmtByte,   /* AL_BYTE */
 322     DevFmtUByte,  /* AL_UNSIGNED_BYTE */
 323     DevFmtShort,  /* AL_SHORT */
 324     DevFmtUShort, /* AL_UNSIGNED_SHORT */
 325     DevFmtFloat,  /* AL_FLOAT */
 326 };
 327 enum DevFmtChannels {
 328     DevFmtMono,   /* AL_MONO */
 329     DevFmtStereo, /* AL_STEREO */
 330     DevFmtQuad,   /* AL_QUAD */
 331     DevFmtX51,    /* AL_5POINT1 */
 332     DevFmtX61,    /* AL_6POINT1 */
 333     DevFmtX71,    /* AL_7POINT1 */
 334 };
 335
 336 ALuint BytesFromDevFmt(enum DevFmtType type);
 337 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans);
 338 static __inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans,
 339                                            enum DevFmtType type)
 340 {
 341     return ChannelsFromDevFmt(chans) * BytesFromDevFmt(type);
 342 }
 343
 344
 345 struct ALCdevice_struct
 346 {
 347     ALCboolean   Connected;
 348     ALboolean    IsCaptureDevice;
 349
 350     ALuint       Frequency;
 351     ALuint       UpdateSize;
 352     ALuint       NumUpdates;
 353     enum DevFmtChannels FmtChans;
 354     enum DevFmtType     FmtType;
 355
 356     ALCchar      *szDeviceName;
 357
 358     ALCenum      LastError;
 359
 360     // Maximum number of sources that can be created
 361     ALuint       MaxNoOfSources;
 362     // Maximum number of slots that can be created
 363     ALuint       AuxiliaryEffectSlotMax;
 364
 365     ALCuint      NumMonoSources;
 366     ALCuint      NumStereoSources;
 367     ALuint       NumAuxSends;
 368
 369     // Map of Buffers for this device
 370     UIntMap BufferMap;
 371
 372     // Map of Effects for this device
 373     UIntMap EffectMap;
 374
 375     // Map of Filters for this device
 376     UIntMap FilterMap;
 377
 378     // Map of Databuffers for this device
 379     UIntMap DatabufferMap;
 380
 381     // Stereo-to-binaural filter
 382     struct bs2b *Bs2b;
 383     ALCint       Bs2bLevel;
 384
 385     // Simulated dampening from head occlusion
 386     ALfloat      HeadDampen;
 387
 388     // Duplicate stereo sources on the side/rear channels
 389     ALboolean    DuplicateStereo;
 390
 391     // Dry path buffer mix
 392     ALfloat DryBuffer[BUFFERSIZE][MAXCHANNELS];
 393
 394     ALuint DevChannels[MAXCHANNELS];
 395
 396     ALfloat ChannelMatrix[MAXCHANNELS][MAXCHANNELS];
 397
 398     Channel Speaker2Chan[MAXCHANNELS];
 399     ALfloat PanningLUT[MAXCHANNELS * LUT_NUM];
 400     ALuint  NumChan;
 401
 402     ALfloat ClickRemoval[MAXCHANNELS];
 403     ALfloat PendingClicks[MAXCHANNELS];
 404
 405     // Contexts created on this device
 406     ALCcontext  **Contexts;
 407     ALuint        NumContexts;
 408
 409     BackendFuncs *Funcs;
 410     void         *ExtraData; // For the backend's use
 411
 412     ALCdevice *next;
 413 };
 414
 415 #define ALCdevice_OpenPlayback(a,b)      ((a)->Funcs->OpenPlayback((a), (b)))
 416 #define ALCdevice_ClosePlayback(a)       ((a)->Funcs->ClosePlayback((a)))
 417 #define ALCdevice_ResetPlayback(a)       ((a)->Funcs->ResetPlayback((a)))
 418 #define ALCdevice_StopPlayback(a)        ((a)->Funcs->StopPlayback((a)))
 419 #define ALCdevice_OpenCapture(a,b)       ((a)->Funcs->OpenCapture((a), (b)))
 420 #define ALCdevice_CloseCapture(a)        ((a)->Funcs->CloseCapture((a)))
 421 #define ALCdevice_StartCapture(a)        ((a)->Funcs->StartCapture((a)))
 422 #define ALCdevice_StopCapture(a)         ((a)->Funcs->StopCapture((a)))
 423 #define ALCdevice_CaptureSamples(a,b,c)  ((a)->Funcs->CaptureSamples((a), (b), (c)))
 424 #define ALCdevice_AvailableSamples(a)    ((a)->Funcs->AvailableSamples((a)))
 425
 426 struct ALCcontext_struct
 427 {
 428     ALlistener  Listener;
 429
 430     UIntMap SourceMap;
 431     UIntMap EffectSlotMap;
 432
 433     struct ALdatabuffer *SampleSource;
 434     struct ALdatabuffer *SampleSink;
 435
 436     ALenum      LastError;
 437
 438     ALboolean   Suspended;
 439
 440     ALenum      DistanceModel;
 441     ALboolean   SourceDistanceModel;
 442
 443     ALfloat     DopplerFactor;
 444     ALfloat     DopplerVelocity;
 445     ALfloat     flSpeedOfSound;
 446
 447     struct ALsource **ActiveSources;
 448     ALsizei           ActiveSourceCount;
 449     ALsizei           MaxActiveSources;
 450
 451     ALCdevice  *Device;
 452     const ALCchar *ExtensionList;
 453
 454     ALCcontext *next;
 455 };
 456
 457 void AppendDeviceList(const ALCchar *name);
 458 void AppendAllDeviceList(const ALCchar *name);
 459 void AppendCaptureDeviceList(const ALCchar *name);
 460
 461 ALCvoid alcSetError(ALCdevice *device, ALenum errorCode);
 462
 463 ALCvoid SuspendContext(ALCcontext *context);
 464 ALCvoid ProcessContext(ALCcontext *context);
 465
 466 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
 467 ALuint StopThread(ALvoid *thread);
 468
 469 ALCcontext *GetContextSuspended(void);
 470
 471 typedef struct RingBuffer RingBuffer;
 472 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 473 void DestroyRingBuffer(RingBuffer *ring);
 474 ALsizei RingBufferSize(RingBuffer *ring);
 475 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 476 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 477
 478 void ReadALConfig(void);
 479 void FreeALConfig(void);
 480 int ConfigValueExists(const char *blockName, const char *keyName);
 481 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
 482 int GetConfigValueInt(const char *blockName, const char *keyName, int def);
 483 float GetConfigValueFloat(const char *blockName, const char *keyName, float def);
 484 int GetConfigValueBool(const char *blockName, const char *keyName, int def);
 485
 486 void SetRTPriority(void);
 487
 488 void SetDefaultChannelOrder(ALCdevice *device);
 489 void SetDefaultWFXChannelOrder(ALCdevice *device);
 490
 491 void al_print(const char *fname, unsigned int line, const char *fmt, ...)
 492              PRINTF_STYLE(3,4);
 493 #define AL_PRINT(...) al_print(__FILE__, __LINE__, __VA_ARGS__)
 494
 495 #ifdef __cplusplus
 496 }
 497 #endif
 498
 499 #endif