OpenAL32/Include/alMain.h

   1 #ifndef AL_MAIN_H
   2 #define AL_MAIN_H
   3
   4 #include <string.h>
   5 #include <stdio.h>
   6
   7 #include "alu.h"
   8
   9 #ifdef HAVE_FENV_H
  10 #include <fenv.h>
  11 #endif
  12
  13 #ifdef _WIN32
  14
  15 #ifndef _WIN32_WINNT
  16 #define _WIN32_WINNT 0x0500
  17 #endif
  18 #include <windows.h>
  19
  20 #else
  21
  22 #include <assert.h>
  23 #include <pthread.h>
  24 #ifdef HAVE_PTHREAD_NP_H
  25 #include <pthread_np.h>
  26 #endif
  27 #include <sys/time.h>
  28 #include <time.h>
  29 #include <errno.h>
  30
  31 #define IsBadWritePtr(a,b) (0)
  32
  33 typedef pthread_mutex_t CRITICAL_SECTION;
  34 static inline void EnterCriticalSection(CRITICAL_SECTION *cs)
  35 {
  36     int ret;
  37     ret = pthread_mutex_lock(cs);
  38     assert(ret == 0);
  39 }
  40 static inline void LeaveCriticalSection(CRITICAL_SECTION *cs)
  41 {
  42     int ret;
  43     ret = pthread_mutex_unlock(cs);
  44     assert(ret == 0);
  45 }
  46 static inline void InitializeCriticalSection(CRITICAL_SECTION *cs)
  47 {
  48     pthread_mutexattr_t attrib;
  49     int ret;
  50
  51     ret = pthread_mutexattr_init(&attrib);
  52     assert(ret == 0);
  53
  54     ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
  55 #ifdef HAVE_PTHREAD_NP_H
  56     if(ret != 0)
  57         ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
  58 #endif
  59     assert(ret == 0);
  60     ret = pthread_mutex_init(cs, &attrib);
  61     assert(ret == 0);
  62
  63     pthread_mutexattr_destroy(&attrib);
  64 }
  65
  66 static inline void DeleteCriticalSection(CRITICAL_SECTION *cs)
  67 {
  68     int ret;
  69     ret = pthread_mutex_destroy(cs);
  70     assert(ret == 0);
  71 }
  72
  73 /* NOTE: This wrapper isn't quite accurate as it returns an ALuint, as opposed
  74  * to the expected DWORD. Both are defined as unsigned 32-bit types, however.
  75  * Additionally, Win32 is supposed to measure the time since Windows started,
  76  * as opposed to the actual time. */
  77 static inline ALuint timeGetTime(void)
  78 {
  79     struct timeval tv;
  80     int ret;
  81
  82     ret = gettimeofday(&tv, NULL);
  83     assert(ret == 0);
  84
  85     return tv.tv_usec/1000 + tv.tv_sec*1000;
  86 }
  87
  88 static inline void Sleep(ALuint t)
  89 {
  90     struct timespec tv, rem;
  91     tv.tv_nsec = (t*1000000)%1000000000;
  92     tv.tv_sec = t/1000;
  93
  94     while(nanosleep(&tv, &rem) == -1 && errno == EINTR)
  95         tv = rem;
  96 }
  97 #define min(x,y) (((x)<(y))?(x):(y))
  98 #define max(x,y) (((x)>(y))?(x):(y))
  99 #endif
 100
 101 #include "AL/al.h"
 102 #include "AL/alc.h"
 103 #include "AL/alext.h"
 104 #include "alListener.h"
 105
 106 #ifdef __cplusplus
 107 extern "C" {
 108 #endif
 109
 110 extern char _alDebug[256];
 111
 112 #define AL_PRINT(...) do {                             \
 113     int _al_print_i;                                   \
 114     const char *_al_print_fn = strrchr(__FILE__, '/'); \
 115     if(!_al_print_fn) _al_print_fn  = __FILE__;        \
 116     else              _al_print_fn += 1;               \
 117     _al_print_i = snprintf(_alDebug, sizeof(_alDebug), "AL lib: %s:%d: ", _al_print_fn, __LINE__); \
 118     if(_al_print_i < (int)sizeof(_alDebug) && _al_print_i > 0)                     \
 119         snprintf(_alDebug+_al_print_i, sizeof(_alDebug)-_al_print_i, __VA_ARGS__); \
 120     _alDebug[sizeof(_alDebug)-1] = 0; \
 121     fprintf(stderr, "%s", _alDebug);  \
 122 } while(0)
 123
 124
 125 #define SWMIXER_OUTPUT_RATE        44100
 126
 127 #define SPEEDOFSOUNDMETRESPERSEC   (343.3f)
 128 #define AIRABSORBGAINDBHF          (-0.05f)
 129
 130 #define LOWPASSFREQCUTOFF          (5000)
 131
 132 #define QUADRANT_NUM 128
 133 #define LUT_NUM (4 * QUADRANT_NUM)
 134
 135
 136 typedef struct {
 137     ALCboolean (*OpenPlayback)(ALCdevice*, const ALCchar*);
 138     void (*ClosePlayback)(ALCdevice*);
 139
 140     ALCboolean (*OpenCapture)(ALCdevice*, const ALCchar*, ALCuint, ALCenum, ALCsizei);
 141     void (*CloseCapture)(ALCdevice*);
 142     void (*StartCapture)(ALCdevice*);
 143     void (*StopCapture)(ALCdevice*);
 144     void (*CaptureSamples)(ALCdevice*, void*, ALCuint);
 145     ALCuint (*AvailableSamples)(ALCdevice*);
 146 } BackendFuncs;
 147
 148 void alc_alsa_init(BackendFuncs *func_list);
 149 void alc_oss_init(BackendFuncs *func_list);
 150 void alc_solaris_init(BackendFuncs *func_list);
 151 void alcDSoundInit(BackendFuncs *func_list);
 152 void alcWinMMInit(BackendFuncs *FuncList);
 153 void alc_pa_init(BackendFuncs *func_list);
 154 void alc_wave_init(BackendFuncs *func_list);
 155 void alc_pulse_init(BackendFuncs *func_list);
 156
 157
 158 struct ALCdevice_struct
 159 {
 160     ALboolean    IsCaptureDevice;
 161
 162     ALuint       Frequency;
 163     ALuint       UpdateSize;
 164     ALenum       Format;
 165
 166     ALCchar      *szDeviceName;
 167
 168     // Maximum number of sources that can be created
 169     ALuint       MaxNoOfSources;
 170
 171     // Context created on this device
 172     ALCcontext   *Context;
 173
 174     BackendFuncs *Funcs;
 175     void         *ExtraData; // For the backend's use
 176
 177     ALCdevice *next;
 178 };
 179
 180 #define ALCdevice_OpenPlayback(a,b)      ((a)->Funcs->OpenPlayback((a), (b)))
 181 #define ALCdevice_ClosePlayback(a)       ((a)->Funcs->ClosePlayback((a)))
 182 #define ALCdevice_OpenCapture(a,b,c,d,e) ((a)->Funcs->OpenCapture((a), (b), (c), (d), (e)))
 183 #define ALCdevice_CloseCapture(a)        ((a)->Funcs->CloseCapture((a)))
 184 #define ALCdevice_StartCapture(a)        ((a)->Funcs->StartCapture((a)))
 185 #define ALCdevice_StopCapture(a)         ((a)->Funcs->StopCapture((a)))
 186 #define ALCdevice_CaptureSamples(a,b,c)  ((a)->Funcs->CaptureSamples((a), (b), (c)))
 187 #define ALCdevice_AvailableSamples(a)    ((a)->Funcs->AvailableSamples((a)))
 188
 189 struct ALCcontext_struct
 190 {
 191     ALlistener  Listener;
 192
 193     struct ALsource *Source;
 194     ALuint           SourceCount;
 195
 196     struct ALeffectslot *AuxiliaryEffectSlot;
 197     ALuint               AuxiliaryEffectSlotCount;
 198     // Maximum number of slots that can be created
 199     ALuint               AuxiliaryEffectSlotMax;
 200
 201     ALenum      LastError;
 202     ALboolean   InUse;
 203
 204     ALuint      Frequency;
 205
 206     ALenum      DistanceModel;
 207
 208     ALfloat     DopplerFactor;
 209     ALfloat     DopplerVelocity;
 210     ALfloat     flSpeedOfSound;
 211
 212     ALint       lNumMonoSources;
 213     ALint       lNumStereoSources;
 214
 215     ALuint      NumSends;
 216
 217     ALfloat     PanningLUT[OUTPUTCHANNELS * LUT_NUM];
 218     ALint       NumChan;
 219
 220     ALfloat     ChannelMatrix[OUTPUTCHANNELS][OUTPUTCHANNELS];
 221
 222     ALCdevice  *Device;
 223     const ALCchar *ExtensionList;
 224
 225     struct bs2b *bs2b;
 226
 227     ALCcontext *next;
 228 };
 229
 230 ALCvoid ReleaseALC(ALCvoid);
 231
 232 ALCchar *AppendDeviceList(char *name);
 233 ALCchar *AppendAllDeviceList(char *name);
 234 ALCchar *AppendCaptureDeviceList(char *name);
 235
 236 ALCvoid SetALCError(ALenum errorCode);
 237
 238 ALCvoid SuspendContext(ALCcontext *context);
 239 ALCvoid ProcessContext(ALCcontext *context);
 240
 241 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr);
 242 ALuint StopThread(ALvoid *thread);
 243
 244 typedef struct RingBuffer RingBuffer;
 245 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length);
 246 void DestroyRingBuffer(RingBuffer *ring);
 247 ALsizei RingBufferSize(RingBuffer *ring);
 248 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len);
 249 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len);
 250
 251 void ReadALConfig(void);
 252 void FreeALConfig(void);
 253 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def);
 254 int GetConfigValueInt(const char *blockName, const char *keyName, int def);
 255 float GetConfigValueFloat(const char *blockName, const char *keyName, float def);
 256
 257 #ifdef __cplusplus
 258 }
 259 #endif
 260
 261 #endif