router/router.cpp

   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 <algorithm>
  11
  12 #include "AL/alc.h"
  13 #include "AL/al.h"
  14 #include "almalloc.h"
  15
  16 #include "version.h"
  17
  18 std::vector<DriverIface> DriverList;
  19
  20 thread_local DriverIface *ThreadCtxDriver;
  21
  22 enum LogLevel LogLevel = LogLevel_Error;
  23 FILE *LogFile;
  24
  25 static void LoadDriverList(void);
  26
  27
  28 BOOL APIENTRY DllMain(HINSTANCE UNUSED(module), DWORD reason, void* UNUSED(reserved))
  29 {
  30     const char *str;
  31
  32     switch(reason)
  33     {
  34         case DLL_PROCESS_ATTACH:
  35             LogFile = stderr;
  36             str = getenv("ALROUTER_LOGFILE");
  37             if(str && *str != '\0')
  38             {
  39                 FILE *f = fopen(str, "w");
  40                 if(f == nullptr)
  41                     ERR("Could not open log file: %s\n", str);
  42                 else
  43                     LogFile = f;
  44             }
  45             str = getenv("ALROUTER_LOGLEVEL");
  46             if(str && *str != '\0')
  47             {
  48                 char *end = nullptr;
  49                 long l = strtol(str, &end, 0);
  50                 if(!end || *end != '\0')
  51                     ERR("Invalid log level value: %s\n", str);
  52                 else if(l < LogLevel_None || l > LogLevel_Trace)
  53                     ERR("Log level out of range: %s\n", str);
  54                 else
  55                     LogLevel = static_cast<enum LogLevel>(l);
  56             }
  57             TRACE("Initializing router v0.1-%s %s\n", ALSOFT_GIT_COMMIT_HASH, ALSOFT_GIT_BRANCH);
  58             LoadDriverList();
  59
  60             break;
  61
  62         case DLL_THREAD_ATTACH:
  63             break;
  64         case DLL_THREAD_DETACH:
  65             break;
  66
  67         case DLL_PROCESS_DETACH:
  68             DriverList.clear();
  69
  70             if(LogFile && LogFile != stderr)
  71                 fclose(LogFile);
  72             LogFile = nullptr;
  73
  74             break;
  75     }
  76     return TRUE;
  77 }
  78
  79
  80 static void AddModule(HMODULE module, const WCHAR *name)
  81 {
  82     for(auto &drv : DriverList)
  83     {
  84         if(drv.Module == module)
  85         {
  86             TRACE("Skipping already-loaded module %p\n", module);
  87             FreeLibrary(module);
  88             return;
  89         }
  90         if(drv.Name == name)
  91         {
  92             TRACE("Skipping similarly-named module %ls\n", name);
  93             FreeLibrary(module);
  94             return;
  95         }
  96     }
  97
  98     DriverList.emplace_back(name, module);
  99     DriverIface &newdrv = DriverList.back();
 100
 101     /* Load required functions. */
 102     int err = 0;
 103 #define LOAD_PROC(x) do {                                                     \
 104     newdrv.x = reinterpret_cast<decltype(newdrv.x)>(                          \
 105         GetProcAddress(module, #x));                                          \
 106     if(!newdrv.x)                                                             \
 107     {                                                                         \
 108         ERR("Failed to find entry point for %s in %ls\n", #x, name);          \
 109         err = 1;                                                              \
 110     }                                                                         \
 111 } while(0)
 112     LOAD_PROC(alcCreateContext);
 113     LOAD_PROC(alcMakeContextCurrent);
 114     LOAD_PROC(alcProcessContext);
 115     LOAD_PROC(alcSuspendContext);
 116     LOAD_PROC(alcDestroyContext);
 117     LOAD_PROC(alcGetCurrentContext);
 118     LOAD_PROC(alcGetContextsDevice);
 119     LOAD_PROC(alcOpenDevice);
 120     LOAD_PROC(alcCloseDevice);
 121     LOAD_PROC(alcGetError);
 122     LOAD_PROC(alcIsExtensionPresent);
 123     LOAD_PROC(alcGetProcAddress);
 124     LOAD_PROC(alcGetEnumValue);
 125     LOAD_PROC(alcGetString);
 126     LOAD_PROC(alcGetIntegerv);
 127     LOAD_PROC(alcCaptureOpenDevice);
 128     LOAD_PROC(alcCaptureCloseDevice);
 129     LOAD_PROC(alcCaptureStart);
 130     LOAD_PROC(alcCaptureStop);
 131     LOAD_PROC(alcCaptureSamples);
 132
 133     LOAD_PROC(alEnable);
 134     LOAD_PROC(alDisable);
 135     LOAD_PROC(alIsEnabled);
 136     LOAD_PROC(alGetString);
 137     LOAD_PROC(alGetBooleanv);
 138     LOAD_PROC(alGetIntegerv);
 139     LOAD_PROC(alGetFloatv);
 140     LOAD_PROC(alGetDoublev);
 141     LOAD_PROC(alGetBoolean);
 142     LOAD_PROC(alGetInteger);
 143     LOAD_PROC(alGetFloat);
 144     LOAD_PROC(alGetDouble);
 145     LOAD_PROC(alGetError);
 146     LOAD_PROC(alIsExtensionPresent);
 147     LOAD_PROC(alGetProcAddress);
 148     LOAD_PROC(alGetEnumValue);
 149     LOAD_PROC(alListenerf);
 150     LOAD_PROC(alListener3f);
 151     LOAD_PROC(alListenerfv);
 152     LOAD_PROC(alListeneri);
 153     LOAD_PROC(alListener3i);
 154     LOAD_PROC(alListeneriv);
 155     LOAD_PROC(alGetListenerf);
 156     LOAD_PROC(alGetListener3f);
 157     LOAD_PROC(alGetListenerfv);
 158     LOAD_PROC(alGetListeneri);
 159     LOAD_PROC(alGetListener3i);
 160     LOAD_PROC(alGetListeneriv);
 161     LOAD_PROC(alGenSources);
 162     LOAD_PROC(alDeleteSources);
 163     LOAD_PROC(alIsSource);
 164     LOAD_PROC(alSourcef);
 165     LOAD_PROC(alSource3f);
 166     LOAD_PROC(alSourcefv);
 167     LOAD_PROC(alSourcei);
 168     LOAD_PROC(alSource3i);
 169     LOAD_PROC(alSourceiv);
 170     LOAD_PROC(alGetSourcef);
 171     LOAD_PROC(alGetSource3f);
 172     LOAD_PROC(alGetSourcefv);
 173     LOAD_PROC(alGetSourcei);
 174     LOAD_PROC(alGetSource3i);
 175     LOAD_PROC(alGetSourceiv);
 176     LOAD_PROC(alSourcePlayv);
 177     LOAD_PROC(alSourceStopv);
 178     LOAD_PROC(alSourceRewindv);
 179     LOAD_PROC(alSourcePausev);
 180     LOAD_PROC(alSourcePlay);
 181     LOAD_PROC(alSourceStop);
 182     LOAD_PROC(alSourceRewind);
 183     LOAD_PROC(alSourcePause);
 184     LOAD_PROC(alSourceQueueBuffers);
 185     LOAD_PROC(alSourceUnqueueBuffers);
 186     LOAD_PROC(alGenBuffers);
 187     LOAD_PROC(alDeleteBuffers);
 188     LOAD_PROC(alIsBuffer);
 189     LOAD_PROC(alBufferf);
 190     LOAD_PROC(alBuffer3f);
 191     LOAD_PROC(alBufferfv);
 192     LOAD_PROC(alBufferi);
 193     LOAD_PROC(alBuffer3i);
 194     LOAD_PROC(alBufferiv);
 195     LOAD_PROC(alGetBufferf);
 196     LOAD_PROC(alGetBuffer3f);
 197     LOAD_PROC(alGetBufferfv);
 198     LOAD_PROC(alGetBufferi);
 199     LOAD_PROC(alGetBuffer3i);
 200     LOAD_PROC(alGetBufferiv);
 201     LOAD_PROC(alBufferData);
 202     LOAD_PROC(alDopplerFactor);
 203     LOAD_PROC(alDopplerVelocity);
 204     LOAD_PROC(alSpeedOfSound);
 205     LOAD_PROC(alDistanceModel);
 206     if(!err)
 207     {
 208         ALCint alc_ver[2] = { 0, 0 };
 209         newdrv.alcGetIntegerv(nullptr, ALC_MAJOR_VERSION, 1, &alc_ver[0]);
 210         newdrv.alcGetIntegerv(nullptr, ALC_MINOR_VERSION, 1, &alc_ver[1]);
 211         if(newdrv.alcGetError(nullptr) == ALC_NO_ERROR)
 212             newdrv.ALCVer = MAKE_ALC_VER(alc_ver[0], alc_ver[1]);
 213         else
 214             newdrv.ALCVer = MAKE_ALC_VER(1, 0);
 215
 216 #undef LOAD_PROC
 217 #define LOAD_PROC(x) do {                                                     \
 218     newdrv.x = reinterpret_cast<decltype(newdrv.x)>(                          \
 219         newdrv.alcGetProcAddress(nullptr, #x));                               \
 220     if(!newdrv.x)                                                             \
 221     {                                                                         \
 222         ERR("Failed to find entry point for %s in %ls\n", #x, name);          \
 223         err = 1;                                                              \
 224     }                                                                         \
 225 } while(0)
 226         if(newdrv.alcIsExtensionPresent(nullptr, "ALC_EXT_thread_local_context"))
 227         {
 228             LOAD_PROC(alcSetThreadContext);
 229             LOAD_PROC(alcGetThreadContext);
 230         }
 231     }
 232
 233     if(err)
 234     {
 235         DriverList.pop_back();
 236         return;
 237     }
 238     TRACE("Loaded module %p, %ls, ALC %d.%d\n", module, name,
 239           newdrv.ALCVer>>8, newdrv.ALCVer&255);
 240 #undef LOAD_PROC
 241 }
 242
 243 static void SearchDrivers(WCHAR *path)
 244 {
 245     WIN32_FIND_DATAW fdata;
 246
 247     TRACE("Searching for drivers in %ls...\n", path);
 248     std::wstring srchPath = path;
 249     srchPath += L"\\*oal.dll";
 250
 251     HANDLE srchHdl = FindFirstFileW(srchPath.c_str(), &fdata);
 252     if(srchHdl != INVALID_HANDLE_VALUE)
 253     {
 254         do {
 255             HMODULE mod;
 256
 257             srchPath = path;
 258             srchPath += L"\\";
 259             srchPath += fdata.cFileName;
 260             TRACE("Found %ls\n", srchPath.c_str());
 261
 262             mod = LoadLibraryW(srchPath.c_str());
 263             if(!mod)
 264                 WARN("Could not load %ls\n", srchPath.c_str());
 265             else
 266                 AddModule(mod, fdata.cFileName);
 267         } while(FindNextFileW(srchHdl, &fdata));
 268         FindClose(srchHdl);
 269     }
 270 }
 271
 272 static WCHAR *strrchrW(WCHAR *str, WCHAR ch)
 273 {
 274     WCHAR *res = nullptr;
 275     while(str && *str != '\0')
 276     {
 277         if(*str == ch)
 278             res = str;
 279         ++str;
 280     }
 281     return res;
 282 }
 283
 284 static int GetLoadedModuleDirectory(const WCHAR *name, WCHAR *moddir, DWORD length)
 285 {
 286     HMODULE module = nullptr;
 287     WCHAR *sep0, *sep1;
 288
 289     if(name)
 290     {
 291         module = GetModuleHandleW(name);
 292         if(!module) return 0;
 293     }
 294
 295     if(GetModuleFileNameW(module, moddir, length) == 0)
 296         return 0;
 297
 298     sep0 = strrchrW(moddir, '/');
 299     if(sep0) sep1 = strrchrW(sep0+1, '\\');
 300     else sep1 = strrchrW(moddir, '\\');
 301
 302     if(sep1) *sep1 = '\0';
 303     else if(sep0) *sep0 = '\0';
 304     else *moddir = '\0';
 305
 306     return 1;
 307 }
 308
 309 void LoadDriverList(void)
 310 {
 311     WCHAR dll_path[MAX_PATH+1] = L"";
 312     WCHAR cwd_path[MAX_PATH+1] = L"";
 313     WCHAR proc_path[MAX_PATH+1] = L"";
 314     WCHAR sys_path[MAX_PATH+1] = L"";
 315     int len;
 316
 317     if(GetLoadedModuleDirectory(L"OpenAL32.dll", dll_path, MAX_PATH))
 318         TRACE("Got DLL path %ls\n", dll_path);
 319
 320     GetCurrentDirectoryW(MAX_PATH, cwd_path);
 321     len = lstrlenW(cwd_path);
 322     if(len > 0 && (cwd_path[len-1] == '\\' || cwd_path[len-1] == '/'))
 323         cwd_path[len-1] = '\0';
 324     TRACE("Got current working directory %ls\n", cwd_path);
 325
 326     if(GetLoadedModuleDirectory(nullptr, proc_path, MAX_PATH))
 327         TRACE("Got proc path %ls\n", proc_path);
 328
 329     GetSystemDirectoryW(sys_path, MAX_PATH);
 330     len = lstrlenW(sys_path);
 331     if(len > 0 && (sys_path[len-1] == '\\' || sys_path[len-1] == '/'))
 332         sys_path[len-1] = '\0';
 333     TRACE("Got system path %ls\n", sys_path);
 334
 335     /* Don't search the DLL's path if it is the same as the current working
 336      * directory, app's path, or system path (don't want to do duplicate
 337      * searches, or increase the priority of the app or system path).
 338      */
 339     if(dll_path[0] &&
 340        (!cwd_path[0] || wcscmp(dll_path, cwd_path) != 0) &&
 341        (!proc_path[0] || wcscmp(dll_path, proc_path) != 0) &&
 342        (!sys_path[0] || wcscmp(dll_path, sys_path) != 0))
 343         SearchDrivers(dll_path);
 344     if(cwd_path[0] &&
 345        (!proc_path[0] || wcscmp(cwd_path, proc_path) != 0) &&
 346        (!sys_path[0] || wcscmp(cwd_path, sys_path) != 0))
 347         SearchDrivers(cwd_path);
 348     if(proc_path[0] && (!sys_path[0] || wcscmp(proc_path, sys_path) != 0))
 349         SearchDrivers(proc_path);
 350     if(sys_path[0])
 351         SearchDrivers(sys_path);
 352 }
 353
 354
 355 PtrIntMap::~PtrIntMap()
 356 {
 357     std::lock_guard<std::mutex> maplock{mLock};
 358     al_free(mKeys);
 359     mKeys = nullptr;
 360     mValues = nullptr;
 361     mSize = 0;
 362     mCapacity = 0;
 363 }
 364
 365 ALenum PtrIntMap::insert(ALvoid *key, ALint value)
 366 {
 367     std::lock_guard<std::mutex> maplock{mLock};
 368     auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
 369     auto pos = static_cast<ALsizei>(std::distance(mKeys, iter));
 370
 371     if(pos == mSize || mKeys[pos] != key)
 372     {
 373         if(mSize == mCapacity)
 374         {
 375             ALvoid **newkeys{nullptr};
 376             ALsizei newcap{mCapacity ? (mCapacity<<1) : 4};
 377             if(newcap > mCapacity)
 378                 newkeys = static_cast<ALvoid**>(
 379                     al_calloc(16, (sizeof(mKeys[0])+sizeof(mValues[0]))*newcap)
 380                 );
 381             if(!newkeys)
 382                 return AL_OUT_OF_MEMORY;
 383             auto newvalues = reinterpret_cast<ALint*>(&newkeys[newcap]);
 384
 385             if(mKeys)
 386             {
 387                 std::copy_n(mKeys, mSize, newkeys);
 388                 std::copy_n(mValues, mSize, newvalues);
 389             }
 390             al_free(mKeys);
 391             mKeys = newkeys;
 392             mValues = newvalues;
 393             mCapacity = newcap;
 394         }
 395
 396         if(pos < mSize)
 397         {
 398             std::copy_backward(mKeys+pos, mKeys+mSize, mKeys+mSize+1);
 399             std::copy_backward(mValues+pos, mValues+mSize, mValues+mSize+1);
 400         }
 401         mSize++;
 402     }
 403     mKeys[pos] = key;
 404     mValues[pos] = value;
 405
 406     return AL_NO_ERROR;
 407 }
 408
 409 ALint PtrIntMap::removeByKey(ALvoid *key)
 410 {
 411     ALint ret = -1;
 412
 413     std::lock_guard<std::mutex> maplock{mLock};
 414     auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
 415     auto pos = static_cast<ALsizei>(std::distance(mKeys, iter));
 416     if(pos < mSize && mKeys[pos] == key)
 417     {
 418         ret = mValues[pos];
 419         if(pos+1 < mSize)
 420         {
 421             std::copy(mKeys+pos+1, mKeys+mSize, mKeys+pos);
 422             std::copy(mValues+pos+1, mValues+mSize, mValues+pos);
 423         }
 424         mSize--;
 425     }
 426
 427     return ret;
 428 }
 429
 430 ALint PtrIntMap::lookupByKey(ALvoid *key)
 431 {
 432     ALint ret = -1;
 433
 434     std::lock_guard<std::mutex> maplock{mLock};
 435     auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
 436     auto pos = static_cast<ALsizei>(std::distance(mKeys, iter));
 437     if(pos < mSize && mKeys[pos] == key)
 438         ret = mValues[pos];
 439
 440     return ret;
 441 }