router/router.c

   1
   2 #include "config.h"
   3
   4 #include "router.h"
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include "AL/alc.h"
  11 #include "AL/al.h"
  12
  13
  14 DriverIface *DriverList = NULL;
  15 int DriverListSize = 0;
  16 static int DriverListSizeMax = 0;
  17
  18 static void LoadDriverList(void);
  19
  20
  21 BOOL APIENTRY DllMain(HINSTANCE UNUSED(module), DWORD reason, void* UNUSED(reserved))
  22 {
  23     int i;
  24
  25     switch(reason)
  26     {
  27         case DLL_PROCESS_ATTACH:
  28             LoadDriverList();
  29             break;
  30
  31         case DLL_THREAD_ATTACH:
  32         case DLL_THREAD_DETACH:
  33             break;
  34
  35         case DLL_PROCESS_DETACH:
  36             ReleaseALC();
  37             for(i = 0;i < DriverListSize;i++)
  38             {
  39                 if(DriverList[i].Module)
  40                     FreeLibrary(DriverList[i].Module);
  41             }
  42             free(DriverList);
  43             DriverList = NULL;
  44             DriverListSize = 0;
  45             DriverListSizeMax = 0;
  46             break;
  47     }
  48     return TRUE;
  49 }
  50
  51
  52 #ifdef __GNUC__
  53 #define CAST_FUNC(x) (__typeof(x))
  54 #else
  55 #define CAST_FUNC(x) (void*)
  56 #endif
  57
  58 static void AddModule(HMODULE module, const WCHAR *name)
  59 {
  60     DriverIface newdrv;
  61     int err = 0;
  62     int i;
  63
  64     for(i = 0;i < DriverListSize;i++)
  65     {
  66         if(DriverList[i].Module == module || wcscmp(DriverList[i].Name, name) == 0)
  67         {
  68             FreeLibrary(module);
  69             return;
  70         }
  71     }
  72
  73     if(DriverListSize == DriverListSizeMax)
  74     {
  75         int newmax = DriverListSizeMax ? DriverListSizeMax<<1 : 4;
  76         void *newlist = calloc(sizeof(DriverList[0]), newmax);
  77         if(!newlist) return;
  78
  79         memcpy(newlist, DriverList, DriverListSize*sizeof(DriverList[0]));
  80         free(DriverList);
  81         DriverList = newlist;
  82         DriverListSizeMax = newmax;
  83     }
  84
  85     memset(&newdrv, 0, sizeof(newdrv));
  86 #define LOAD_PROC(x) do {                                                     \
  87     newdrv.x = CAST_FUNC(newdrv.x) GetProcAddress(module, #x);                \
  88     if(!newdrv.x)                                                             \
  89     {                                                                         \
  90         fprintf(stderr, "Failed to find entry point for %s in %ls\n",         \
  91                 #x, name);                                                    \
  92         err = 1;                                                              \
  93     }                                                                         \
  94 } while(0)
  95     LOAD_PROC(alcCreateContext);
  96     LOAD_PROC(alcMakeContextCurrent);
  97     LOAD_PROC(alcProcessContext);
  98     LOAD_PROC(alcSuspendContext);
  99     LOAD_PROC(alcDestroyContext);
 100     LOAD_PROC(alcGetCurrentContext);
 101     LOAD_PROC(alcGetContextsDevice);
 102     LOAD_PROC(alcOpenDevice);
 103     LOAD_PROC(alcCloseDevice);
 104     LOAD_PROC(alcGetError);
 105     LOAD_PROC(alcIsExtensionPresent);
 106     LOAD_PROC(alcGetProcAddress);
 107     LOAD_PROC(alcGetEnumValue);
 108     LOAD_PROC(alcGetString);
 109     LOAD_PROC(alcGetIntegerv);
 110     LOAD_PROC(alcCaptureOpenDevice);
 111     LOAD_PROC(alcCaptureCloseDevice);
 112     LOAD_PROC(alcCaptureStart);
 113     LOAD_PROC(alcCaptureStop);
 114     LOAD_PROC(alcCaptureSamples);
 115
 116     LOAD_PROC(alEnable);
 117     LOAD_PROC(alDisable);
 118     LOAD_PROC(alIsEnabled);
 119     LOAD_PROC(alGetString);
 120     LOAD_PROC(alGetBooleanv);
 121     LOAD_PROC(alGetIntegerv);
 122     LOAD_PROC(alGetFloatv);
 123     LOAD_PROC(alGetDoublev);
 124     LOAD_PROC(alGetBoolean);
 125     LOAD_PROC(alGetInteger);
 126     LOAD_PROC(alGetFloat);
 127     LOAD_PROC(alGetDouble);
 128     LOAD_PROC(alGetError);
 129     LOAD_PROC(alIsExtensionPresent);
 130     LOAD_PROC(alGetProcAddress);
 131     LOAD_PROC(alGetEnumValue);
 132     LOAD_PROC(alListenerf);
 133     LOAD_PROC(alListener3f);
 134     LOAD_PROC(alListenerfv);
 135     LOAD_PROC(alListeneri);
 136     LOAD_PROC(alListener3i);
 137     LOAD_PROC(alListeneriv);
 138     LOAD_PROC(alGetListenerf);
 139     LOAD_PROC(alGetListener3f);
 140     LOAD_PROC(alGetListenerfv);
 141     LOAD_PROC(alGetListeneri);
 142     LOAD_PROC(alGetListener3i);
 143     LOAD_PROC(alGetListeneriv);
 144     LOAD_PROC(alGenSources);
 145     LOAD_PROC(alDeleteSources);
 146     LOAD_PROC(alIsSource);
 147     LOAD_PROC(alSourcef);
 148     LOAD_PROC(alSource3f);
 149     LOAD_PROC(alSourcefv);
 150     LOAD_PROC(alSourcei);
 151     LOAD_PROC(alSource3i);
 152     LOAD_PROC(alSourceiv);
 153     LOAD_PROC(alGetSourcef);
 154     LOAD_PROC(alGetSource3f);
 155     LOAD_PROC(alGetSourcefv);
 156     LOAD_PROC(alGetSourcei);
 157     LOAD_PROC(alGetSource3i);
 158     LOAD_PROC(alGetSourceiv);
 159     LOAD_PROC(alSourcePlayv);
 160     LOAD_PROC(alSourceStopv);
 161     LOAD_PROC(alSourceRewindv);
 162     LOAD_PROC(alSourcePausev);
 163     LOAD_PROC(alSourcePlay);
 164     LOAD_PROC(alSourceStop);
 165     LOAD_PROC(alSourceRewind);
 166     LOAD_PROC(alSourcePause);
 167     LOAD_PROC(alSourceQueueBuffers);
 168     LOAD_PROC(alSourceUnqueueBuffers);
 169     LOAD_PROC(alGenBuffers);
 170     LOAD_PROC(alDeleteBuffers);
 171     LOAD_PROC(alIsBuffer);
 172     LOAD_PROC(alBufferf);
 173     LOAD_PROC(alBuffer3f);
 174     LOAD_PROC(alBufferfv);
 175     LOAD_PROC(alBufferi);
 176     LOAD_PROC(alBuffer3i);
 177     LOAD_PROC(alBufferiv);
 178     LOAD_PROC(alGetBufferf);
 179     LOAD_PROC(alGetBuffer3f);
 180     LOAD_PROC(alGetBufferfv);
 181     LOAD_PROC(alGetBufferi);
 182     LOAD_PROC(alGetBuffer3i);
 183     LOAD_PROC(alGetBufferiv);
 184     LOAD_PROC(alBufferData);
 185     LOAD_PROC(alDopplerFactor);
 186     LOAD_PROC(alDopplerVelocity);
 187     LOAD_PROC(alSpeedOfSound);
 188     LOAD_PROC(alDistanceModel);
 189     if(!err)
 190     {
 191         ALCint alc_ver[2];
 192         wcsncpy(newdrv.Name, name, 32);
 193         newdrv.Module = module;
 194         newdrv.alcGetIntegerv(NULL, ALC_MAJOR_VERSION, 1, &alc_ver[0]);
 195         newdrv.alcGetIntegerv(NULL, ALC_MINOR_VERSION, 1, &alc_ver[1]);
 196         if(newdrv.alcGetError(NULL) == ALC_NO_ERROR)
 197             newdrv.ALCVer = MAKE_ALC_VER(alc_ver[0], alc_ver[1]);
 198         else
 199             newdrv.ALCVer = MAKE_ALC_VER(1, 0);
 200         DriverList[DriverListSize++] = newdrv;
 201     }
 202 }
 203
 204 static void SearchDrivers(WCHAR *path)
 205 {
 206     WCHAR srchPath[MAX_PATH+1] = L"";
 207     WIN32_FIND_DATAW fdata;
 208     HANDLE srchHdl;
 209
 210     wcsncpy(srchPath, path, MAX_PATH);
 211     wcsncat(srchPath, L"\\*oal.dll", MAX_PATH - lstrlenW(srchPath));
 212     srchHdl = FindFirstFileW(srchPath, &fdata);
 213     if(srchHdl != INVALID_HANDLE_VALUE)
 214     {
 215         do {
 216             HMODULE mod;
 217
 218             wcsncpy(srchPath, path, MAX_PATH);
 219             wcsncat(srchPath, L"\\", MAX_PATH - lstrlenW(srchPath));
 220             wcsncat(srchPath, fdata.cFileName, MAX_PATH - lstrlenW(srchPath));
 221
 222             mod = LoadLibraryW(srchPath);
 223             if(mod) AddModule(mod, fdata.cFileName);
 224         } while(FindNextFileW(srchHdl, &fdata));
 225         FindClose(srchHdl);
 226     }
 227 }
 228
 229 static WCHAR *strrchrW(WCHAR *str, WCHAR ch)
 230 {
 231     WCHAR *res = NULL;
 232     while(str && *str != '\0')
 233     {
 234         if(*str == ch)
 235             res = str;
 236         ++str;
 237     }
 238     return res;
 239 }
 240
 241 static int GetLoadedModuleDirectory(const WCHAR *name, WCHAR *moddir, DWORD length)
 242 {
 243     HMODULE module = NULL;
 244     WCHAR *sep0, *sep1;
 245
 246     if(name)
 247     {
 248         module = GetModuleHandleW(name);
 249         if(!module) return 0;
 250     }
 251
 252     if(GetModuleFileNameW(module, moddir, length) == 0)
 253         return 0;
 254
 255     sep0 = strrchrW(moddir, '/');
 256     if(sep0) sep1 = strrchrW(sep0+1, '\\');
 257     else sep1 = strrchrW(moddir, '\\');
 258
 259     if(sep1) *sep1 = '\0';
 260     else if(sep0) *sep0 = '\0';
 261     else *moddir = '\0';
 262
 263     return 1;
 264 }
 265
 266 void LoadDriverList(void)
 267 {
 268     WCHAR path[MAX_PATH+1] = L"";
 269     int len;
 270
 271     if(GetLoadedModuleDirectory(L"OpenAL32.dll", path, MAX_PATH))
 272         SearchDrivers(path);
 273
 274     GetCurrentDirectoryW(MAX_PATH, path);
 275     len = lstrlenW(path);
 276     if(len > 0 && (path[len-1] == '\\' || path[len-1] == '/'))
 277         path[len-1] = '\0';
 278     SearchDrivers(path);
 279
 280     if(GetLoadedModuleDirectory(NULL, path, MAX_PATH))
 281         SearchDrivers(path);
 282
 283     GetSystemDirectoryW(path, MAX_PATH);
 284     len = lstrlenW(path);
 285     if(len > 0 && (path[len-1] == '\\' || path[len-1] == '/'))
 286         path[len-1] = '\0';
 287     SearchDrivers(path);
 288 }
 289
 290
 291 void InitPtrIntMap(PtrIntMap *map)
 292 {
 293     map->keys = NULL;
 294     map->values = NULL;
 295     map->size = 0;
 296     map->capacity = 0;
 297     RWLockInit(&map->lock);
 298 }
 299
 300 void ResetPtrIntMap(PtrIntMap *map)
 301 {
 302     WriteLock(&map->lock);
 303     free(map->keys);
 304     map->keys = NULL;
 305     map->values = NULL;
 306     map->size = 0;
 307     map->capacity = 0;
 308     WriteUnlock(&map->lock);
 309 }
 310
 311 ALenum InsertPtrIntMapEntry(PtrIntMap *map, ALvoid *key, ALint value)
 312 {
 313     ALsizei pos = 0;
 314
 315     WriteLock(&map->lock);
 316     if(map->size > 0)
 317     {
 318         ALsizei count = map->size;
 319         do {
 320             ALsizei step = count>>1;
 321             ALsizei i = pos+step;
 322             if(!(map->keys[i] < key))
 323                 count = step;
 324             else
 325             {
 326                 pos = i+1;
 327                 count -= step+1;
 328             }
 329         } while(count > 0);
 330     }
 331
 332     if(pos == map->size || map->keys[pos] != key)
 333     {
 334         if(map->size == map->capacity)
 335         {
 336             ALvoid **keys = NULL;
 337             ALint *values;
 338             ALsizei newcap;
 339
 340             newcap = (map->capacity ? (map->capacity<<1) : 4);
 341             if(newcap > map->capacity)
 342                 keys = calloc(sizeof(map->keys[0])+sizeof(map->values[0]), newcap);
 343             if(!keys)
 344             {
 345                 WriteUnlock(&map->lock);
 346                 return AL_OUT_OF_MEMORY;
 347             }
 348             values = (ALint*)&keys[newcap];
 349
 350             if(map->keys)
 351             {
 352                 memcpy(keys, map->keys, map->size*sizeof(map->keys[0]));
 353                 memcpy(values, map->values, map->size*sizeof(map->values[0]));
 354             }
 355             free(map->keys);
 356             map->keys = keys;
 357             map->values = values;
 358             map->capacity = newcap;
 359         }
 360
 361         if(pos < map->size)
 362         {
 363             memmove(&map->keys[pos+1], &map->keys[pos],
 364                     (map->size-pos)*sizeof(map->keys[0]));
 365             memmove(&map->values[pos+1], &map->values[pos],
 366                     (map->size-pos)*sizeof(map->values[0]));
 367         }
 368         map->size++;
 369     }
 370     map->keys[pos] = key;
 371     map->values[pos] = value;
 372     WriteUnlock(&map->lock);
 373
 374     return AL_NO_ERROR;
 375 }
 376
 377 ALint RemovePtrIntMapKey(PtrIntMap *map, ALvoid *key)
 378 {
 379     ALint ret = -1;
 380     WriteLock(&map->lock);
 381     if(map->size > 0)
 382     {
 383         ALsizei pos = 0;
 384         ALsizei count = map->size;
 385         do {
 386             ALsizei step = count>>1;
 387             ALsizei i = pos+step;
 388             if(!(map->keys[i] < key))
 389                 count = step;
 390             else
 391             {
 392                 pos = i+1;
 393                 count -= step+1;
 394             }
 395         } while(count > 0);
 396         if(pos < map->size && map->keys[pos] == key)
 397         {
 398             ret = map->values[pos];
 399             if(pos < map->size-1)
 400             {
 401                 memmove(&map->keys[pos], &map->keys[pos+1],
 402                         (map->size-1-pos)*sizeof(map->keys[0]));
 403                 memmove(&map->values[pos], &map->values[pos+1],
 404                         (map->size-1-pos)*sizeof(map->values[0]));
 405             }
 406             map->size--;
 407         }
 408     }
 409     WriteUnlock(&map->lock);
 410     return ret;
 411 }
 412
 413 ALint LookupPtrIntMapKey(PtrIntMap *map, ALvoid *key)
 414 {
 415     ALint ret = -1;
 416     ReadLock(&map->lock);
 417     if(map->size > 0)
 418     {
 419         ALsizei pos = 0;
 420         ALsizei count = map->size;
 421         do {
 422             ALsizei step = count>>1;
 423             ALsizei i = pos+step;
 424             if(!(map->keys[i] < key))
 425                 count = step;
 426             else
 427             {
 428                 pos = i+1;
 429                 count -= step+1;
 430             }
 431         } while(count > 0);
 432         if(pos < map->size && map->keys[pos] == key)
 433             ret = map->values[pos];
 434     }
 435     ReadUnlock(&map->lock);
 436     return ret;
 437 }