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