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