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