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