mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-07-14 08:04:40 +00:00
update openal
This commit is contained in:
AzaezelX
parent
62f3b93ff9
commit
6721a6b021
287 changed files with 33851 additions and 27325 deletions
|
|
@ -4,83 +4,34 @@
|
|||
#include "router.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <vector>
|
||||
|
||||
#include "AL/alc.h"
|
||||
#include "AL/al.h"
|
||||
|
||||
#include "almalloc.h"
|
||||
#include "alstring.h"
|
||||
#include "opthelpers.h"
|
||||
#include "strutils.h"
|
||||
|
||||
#include "version.h"
|
||||
|
||||
|
||||
std::vector<DriverIfacePtr> DriverList;
|
||||
eLogLevel LogLevel{eLogLevel::Error};
|
||||
gsl::owner<std::FILE*> LogFile;
|
||||
|
||||
thread_local DriverIface *ThreadCtxDriver;
|
||||
namespace {
|
||||
|
||||
enum LogLevel LogLevel = LogLevel_Error;
|
||||
FILE *LogFile;
|
||||
|
||||
#ifdef __MINGW32__
|
||||
DriverIface *GetThreadDriver() noexcept { return ThreadCtxDriver; }
|
||||
void SetThreadDriver(DriverIface *driver) noexcept { ThreadCtxDriver = driver; }
|
||||
#endif
|
||||
|
||||
static void LoadDriverList(void);
|
||||
std::vector<std::wstring> gAcceptList;
|
||||
std::vector<std::wstring> gRejectList;
|
||||
|
||||
|
||||
BOOL APIENTRY DllMain(HINSTANCE, DWORD reason, void*)
|
||||
{
|
||||
switch(reason)
|
||||
{
|
||||
case DLL_PROCESS_ATTACH:
|
||||
LogFile = stderr;
|
||||
if(auto logfname = al::getenv("ALROUTER_LOGFILE"))
|
||||
{
|
||||
FILE *f = fopen(logfname->c_str(), "w");
|
||||
if(f == nullptr)
|
||||
ERR("Could not open log file: %s\n", logfname->c_str());
|
||||
else
|
||||
LogFile = f;
|
||||
}
|
||||
if(auto loglev = al::getenv("ALROUTER_LOGLEVEL"))
|
||||
{
|
||||
char *end = nullptr;
|
||||
long l = strtol(loglev->c_str(), &end, 0);
|
||||
if(!end || *end != '\0')
|
||||
ERR("Invalid log level value: %s\n", loglev->c_str());
|
||||
else if(l < LogLevel_None || l > LogLevel_Trace)
|
||||
ERR("Log level out of range: %s\n", loglev->c_str());
|
||||
else
|
||||
LogLevel = static_cast<enum LogLevel>(l);
|
||||
}
|
||||
TRACE("Initializing router v0.1-%s %s\n", ALSOFT_GIT_COMMIT_HASH, ALSOFT_GIT_BRANCH);
|
||||
LoadDriverList();
|
||||
|
||||
break;
|
||||
|
||||
case DLL_THREAD_ATTACH:
|
||||
break;
|
||||
case DLL_THREAD_DETACH:
|
||||
break;
|
||||
|
||||
case DLL_PROCESS_DETACH:
|
||||
DriverList.clear();
|
||||
|
||||
if(LogFile && LogFile != stderr)
|
||||
fclose(LogFile);
|
||||
LogFile = nullptr;
|
||||
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
static void AddModule(HMODULE module, const WCHAR *name)
|
||||
void AddModule(HMODULE module, const std::wstring_view name)
|
||||
{
|
||||
for(auto &drv : DriverList)
|
||||
{
|
||||
|
|
@ -92,26 +43,55 @@ static void AddModule(HMODULE module, const WCHAR *name)
|
|||
}
|
||||
if(drv->Name == name)
|
||||
{
|
||||
TRACE("Skipping similarly-named module %ls\n", name);
|
||||
TRACE("Skipping similarly-named module %.*ls\n", al::sizei(name), name.data());
|
||||
FreeLibrary(module);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if(!gAcceptList.empty())
|
||||
{
|
||||
auto iter = std::find_if(gAcceptList.cbegin(), gAcceptList.cend(),
|
||||
[name](const std::wstring_view accept)
|
||||
{ return al::case_compare(name, accept) == 0; });
|
||||
if(iter == gAcceptList.cend())
|
||||
{
|
||||
TRACE("%.*ls not found in ALROUTER_ACCEPT, skipping\n", al::sizei(name), name.data());
|
||||
FreeLibrary(module);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if(!gRejectList.empty())
|
||||
{
|
||||
auto iter = std::find_if(gRejectList.cbegin(), gRejectList.cend(),
|
||||
[name](const std::wstring_view accept)
|
||||
{ return al::case_compare(name, accept) == 0; });
|
||||
if(iter != gRejectList.cend())
|
||||
{
|
||||
TRACE("%.*ls found in ALROUTER_REJECT, skipping\n", al::sizei(name), name.data());
|
||||
FreeLibrary(module);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
DriverList.emplace_back(std::make_unique<DriverIface>(name, module));
|
||||
DriverIface &newdrv = *DriverList.back();
|
||||
DriverIface &newdrv = *DriverList.emplace_back(std::make_unique<DriverIface>(name, module));
|
||||
|
||||
/* Load required functions. */
|
||||
int err = 0;
|
||||
#define LOAD_PROC(x) do { \
|
||||
newdrv.x = reinterpret_cast<decltype(newdrv.x)>(reinterpret_cast<void*>( \
|
||||
GetProcAddress(module, #x))); \
|
||||
if(!newdrv.x) \
|
||||
{ \
|
||||
ERR("Failed to find entry point for %s in %ls\n", #x, name); \
|
||||
err = 1; \
|
||||
} \
|
||||
} while(0)
|
||||
bool loadok{true};
|
||||
auto do_load = [module,name](auto &func, const char *fname) -> bool
|
||||
{
|
||||
using func_t = std::remove_reference_t<decltype(func)>;
|
||||
auto ptr = GetProcAddress(module, fname);
|
||||
if(!ptr)
|
||||
{
|
||||
ERR("Failed to find entry point for %s in %.*ls\n", fname, al::sizei(name),
|
||||
name.data());
|
||||
return false;
|
||||
}
|
||||
|
||||
func = reinterpret_cast<func_t>(reinterpret_cast<void*>(ptr));
|
||||
return true;
|
||||
};
|
||||
#define LOAD_PROC(x) loadok &= do_load(newdrv.x, #x)
|
||||
LOAD_PROC(alcCreateContext);
|
||||
LOAD_PROC(alcMakeContextCurrent);
|
||||
LOAD_PROC(alcProcessContext);
|
||||
|
|
@ -194,264 +174,269 @@ static void AddModule(HMODULE module, const WCHAR *name)
|
|||
LOAD_PROC(alDopplerVelocity);
|
||||
LOAD_PROC(alSpeedOfSound);
|
||||
LOAD_PROC(alDistanceModel);
|
||||
if(!err)
|
||||
#undef LOAD_PROC
|
||||
if(loadok)
|
||||
{
|
||||
ALCint alc_ver[2] = { 0, 0 };
|
||||
std::array<ALCint,2> alc_ver{0, 0};
|
||||
newdrv.alcGetIntegerv(nullptr, ALC_MAJOR_VERSION, 1, &alc_ver[0]);
|
||||
newdrv.alcGetIntegerv(nullptr, ALC_MINOR_VERSION, 1, &alc_ver[1]);
|
||||
if(newdrv.alcGetError(nullptr) == ALC_NO_ERROR)
|
||||
newdrv.ALCVer = MAKE_ALC_VER(alc_ver[0], alc_ver[1]);
|
||||
else
|
||||
{
|
||||
WARN("Failed to query ALC version for %ls, assuming 1.0\n", name);
|
||||
WARN("Failed to query ALC version for %.*ls, assuming 1.0\n", al::sizei(name),
|
||||
name.data());
|
||||
newdrv.ALCVer = MAKE_ALC_VER(1, 0);
|
||||
}
|
||||
|
||||
auto do_load2 = [module,name](auto &func, const char *fname) -> void
|
||||
{
|
||||
using func_t = std::remove_reference_t<decltype(func)>;
|
||||
auto ptr = GetProcAddress(module, fname);
|
||||
if(!ptr)
|
||||
WARN("Failed to find optional entry point for %s in %.*ls\n", fname,
|
||||
al::sizei(name), name.data());
|
||||
else
|
||||
func = reinterpret_cast<func_t>(reinterpret_cast<void*>(ptr));
|
||||
};
|
||||
#define LOAD_PROC(x) do_load2(newdrv.x, #x)
|
||||
LOAD_PROC(alBufferf);
|
||||
LOAD_PROC(alBuffer3f);
|
||||
LOAD_PROC(alBufferfv);
|
||||
LOAD_PROC(alBufferi);
|
||||
LOAD_PROC(alBuffer3i);
|
||||
LOAD_PROC(alBufferiv);
|
||||
LOAD_PROC(alGetBufferf);
|
||||
LOAD_PROC(alGetBuffer3f);
|
||||
LOAD_PROC(alGetBufferfv);
|
||||
LOAD_PROC(alGetBufferi);
|
||||
LOAD_PROC(alGetBuffer3i);
|
||||
LOAD_PROC(alGetBufferiv);
|
||||
#undef LOAD_PROC
|
||||
#define LOAD_PROC(x) do { \
|
||||
newdrv.x = reinterpret_cast<decltype(newdrv.x)>(reinterpret_cast<void*>( \
|
||||
GetProcAddress(module, #x))); \
|
||||
if(!newdrv.x) \
|
||||
{ \
|
||||
WARN("Failed to find optional entry point for %s in %ls\n", #x, name); \
|
||||
} \
|
||||
} while(0)
|
||||
LOAD_PROC(alBufferf);
|
||||
LOAD_PROC(alBuffer3f);
|
||||
LOAD_PROC(alBufferfv);
|
||||
LOAD_PROC(alBufferi);
|
||||
LOAD_PROC(alBuffer3i);
|
||||
LOAD_PROC(alBufferiv);
|
||||
LOAD_PROC(alGetBufferf);
|
||||
LOAD_PROC(alGetBuffer3f);
|
||||
LOAD_PROC(alGetBufferfv);
|
||||
LOAD_PROC(alGetBufferi);
|
||||
LOAD_PROC(alGetBuffer3i);
|
||||
LOAD_PROC(alGetBufferiv);
|
||||
|
||||
#undef LOAD_PROC
|
||||
#define LOAD_PROC(x) do { \
|
||||
newdrv.x = reinterpret_cast<decltype(newdrv.x)>( \
|
||||
newdrv.alcGetProcAddress(nullptr, #x)); \
|
||||
if(!newdrv.x) \
|
||||
{ \
|
||||
ERR("Failed to find entry point for %s in %ls\n", #x, name); \
|
||||
err = 1; \
|
||||
} \
|
||||
} while(0)
|
||||
auto do_load3 = [name,&newdrv](auto &func, const char *fname) -> bool
|
||||
{
|
||||
using func_t = std::remove_reference_t<decltype(func)>;
|
||||
auto ptr = newdrv.alcGetProcAddress(nullptr, fname);
|
||||
if(!ptr)
|
||||
{
|
||||
ERR("Failed to find entry point for %s in %.*ls\n", fname, al::sizei(name),
|
||||
name.data());
|
||||
return false;
|
||||
}
|
||||
|
||||
func = reinterpret_cast<func_t>(ptr);
|
||||
return true;
|
||||
};
|
||||
#define LOAD_PROC(x) loadok &= do_load3(newdrv.x, #x)
|
||||
if(newdrv.alcIsExtensionPresent(nullptr, "ALC_EXT_thread_local_context"))
|
||||
{
|
||||
LOAD_PROC(alcSetThreadContext);
|
||||
LOAD_PROC(alcGetThreadContext);
|
||||
}
|
||||
#undef LOAD_PROC
|
||||
}
|
||||
|
||||
if(err)
|
||||
if(!loadok)
|
||||
{
|
||||
DriverList.pop_back();
|
||||
return;
|
||||
}
|
||||
TRACE("Loaded module %p, %ls, ALC %d.%d\n", decltype(std::declval<void*>()){module}, name,
|
||||
newdrv.ALCVer>>8, newdrv.ALCVer&255);
|
||||
#undef LOAD_PROC
|
||||
TRACE("Loaded module %p, %.*ls, ALC %d.%d\n", decltype(std::declval<void*>()){module},
|
||||
al::sizei(name), name.data(), newdrv.ALCVer>>8, newdrv.ALCVer&255);
|
||||
}
|
||||
|
||||
static void SearchDrivers(WCHAR *path)
|
||||
void SearchDrivers(const std::wstring_view path)
|
||||
{
|
||||
WIN32_FIND_DATAW fdata;
|
||||
|
||||
TRACE("Searching for drivers in %ls...\n", path);
|
||||
std::wstring srchPath = path;
|
||||
TRACE("Searching for drivers in %.*ls...\n", al::sizei(path), path.data());
|
||||
std::wstring srchPath{path};
|
||||
srchPath += L"\\*oal.dll";
|
||||
|
||||
HANDLE srchHdl = FindFirstFileW(srchPath.c_str(), &fdata);
|
||||
if(srchHdl != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
do {
|
||||
HMODULE mod;
|
||||
WIN32_FIND_DATAW fdata{};
|
||||
HANDLE srchHdl{FindFirstFileW(srchPath.c_str(), &fdata)};
|
||||
if(srchHdl == INVALID_HANDLE_VALUE) return;
|
||||
|
||||
srchPath = path;
|
||||
srchPath += L"\\";
|
||||
srchPath += fdata.cFileName;
|
||||
TRACE("Found %ls\n", srchPath.c_str());
|
||||
do {
|
||||
srchPath = path;
|
||||
srchPath += L"\\";
|
||||
srchPath += std::data(fdata.cFileName);
|
||||
TRACE("Found %ls\n", srchPath.c_str());
|
||||
|
||||
mod = LoadLibraryW(srchPath.c_str());
|
||||
if(!mod)
|
||||
WARN("Could not load %ls\n", srchPath.c_str());
|
||||
else
|
||||
AddModule(mod, fdata.cFileName);
|
||||
} while(FindNextFileW(srchHdl, &fdata));
|
||||
FindClose(srchHdl);
|
||||
}
|
||||
HMODULE mod{LoadLibraryW(srchPath.c_str())};
|
||||
if(!mod)
|
||||
WARN("Could not load %ls\n", srchPath.c_str());
|
||||
else
|
||||
AddModule(mod, std::data(fdata.cFileName));
|
||||
} while(FindNextFileW(srchHdl, &fdata));
|
||||
FindClose(srchHdl);
|
||||
}
|
||||
|
||||
static WCHAR *strrchrW(WCHAR *str, WCHAR ch)
|
||||
bool GetLoadedModuleDirectory(const WCHAR *name, std::wstring *moddir)
|
||||
{
|
||||
WCHAR *res = nullptr;
|
||||
while(str && *str != '\0')
|
||||
{
|
||||
if(*str == ch)
|
||||
res = str;
|
||||
++str;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static int GetLoadedModuleDirectory(const WCHAR *name, WCHAR *moddir, DWORD length)
|
||||
{
|
||||
HMODULE module = nullptr;
|
||||
WCHAR *sep0, *sep1;
|
||||
HMODULE module{nullptr};
|
||||
|
||||
if(name)
|
||||
{
|
||||
module = GetModuleHandleW(name);
|
||||
if(!module) return 0;
|
||||
if(!module) return false;
|
||||
}
|
||||
|
||||
if(GetModuleFileNameW(module, moddir, length) == 0)
|
||||
return 0;
|
||||
moddir->assign(256, '\0');
|
||||
DWORD res{GetModuleFileNameW(module, moddir->data(), static_cast<DWORD>(moddir->size()))};
|
||||
if(res >= moddir->size())
|
||||
{
|
||||
do {
|
||||
moddir->append(256, '\0');
|
||||
res = GetModuleFileNameW(module, moddir->data(), static_cast<DWORD>(moddir->size()));
|
||||
} while(res >= moddir->size());
|
||||
}
|
||||
moddir->resize(res);
|
||||
|
||||
sep0 = strrchrW(moddir, '/');
|
||||
if(sep0) sep1 = strrchrW(sep0+1, '\\');
|
||||
else sep1 = strrchrW(moddir, '\\');
|
||||
auto sep0 = moddir->rfind('/');
|
||||
auto sep1 = moddir->rfind('\\');
|
||||
if(sep0 < moddir->size() && sep1 < moddir->size())
|
||||
moddir->resize(std::max(sep0, sep1));
|
||||
else if(sep0 < moddir->size())
|
||||
moddir->resize(sep0);
|
||||
else if(sep1 < moddir->size())
|
||||
moddir->resize(sep1);
|
||||
else
|
||||
moddir->resize(0);
|
||||
|
||||
if(sep1) *sep1 = '\0';
|
||||
else if(sep0) *sep0 = '\0';
|
||||
else *moddir = '\0';
|
||||
|
||||
return 1;
|
||||
return !moddir->empty();
|
||||
}
|
||||
|
||||
void LoadDriverList(void)
|
||||
void LoadDriverList()
|
||||
{
|
||||
WCHAR dll_path[MAX_PATH+1] = L"";
|
||||
WCHAR cwd_path[MAX_PATH+1] = L"";
|
||||
WCHAR proc_path[MAX_PATH+1] = L"";
|
||||
WCHAR sys_path[MAX_PATH+1] = L"";
|
||||
int len;
|
||||
if(auto list = al::getenv(L"ALROUTER_ACCEPT"))
|
||||
{
|
||||
std::wstring_view namelist{*list};
|
||||
while(!namelist.empty())
|
||||
{
|
||||
auto seppos = namelist.find(',');
|
||||
if(seppos > 0)
|
||||
gAcceptList.emplace_back(namelist.substr(0, seppos));
|
||||
if(seppos < namelist.size())
|
||||
namelist.remove_prefix(seppos+1);
|
||||
else
|
||||
namelist.remove_prefix(namelist.size());
|
||||
}
|
||||
}
|
||||
if(auto list = al::getenv(L"ALROUTER_REJECT"))
|
||||
{
|
||||
std::wstring_view namelist{*list};
|
||||
while(!namelist.empty())
|
||||
{
|
||||
auto seppos = namelist.find(',');
|
||||
if(seppos > 0)
|
||||
gRejectList.emplace_back(namelist.substr(0, seppos));
|
||||
if(seppos < namelist.size())
|
||||
namelist.remove_prefix(seppos+1);
|
||||
else
|
||||
namelist.remove_prefix(namelist.size());
|
||||
}
|
||||
}
|
||||
|
||||
if(GetLoadedModuleDirectory(L"OpenAL32.dll", dll_path, MAX_PATH))
|
||||
TRACE("Got DLL path %ls\n", dll_path);
|
||||
std::wstring dll_path;
|
||||
if(GetLoadedModuleDirectory(L"OpenAL32.dll", &dll_path))
|
||||
TRACE("Got DLL path %ls\n", dll_path.c_str());
|
||||
|
||||
GetCurrentDirectoryW(MAX_PATH, cwd_path);
|
||||
len = lstrlenW(cwd_path);
|
||||
if(len > 0 && (cwd_path[len-1] == '\\' || cwd_path[len-1] == '/'))
|
||||
cwd_path[len-1] = '\0';
|
||||
TRACE("Got current working directory %ls\n", cwd_path);
|
||||
std::wstring cwd_path;
|
||||
if(DWORD pathlen{GetCurrentDirectoryW(0, nullptr)})
|
||||
{
|
||||
do {
|
||||
cwd_path.resize(pathlen);
|
||||
pathlen = GetCurrentDirectoryW(pathlen, cwd_path.data());
|
||||
} while(pathlen >= cwd_path.size());
|
||||
cwd_path.resize(pathlen);
|
||||
}
|
||||
if(!cwd_path.empty() && (cwd_path.back() == '\\' || cwd_path.back() == '/'))
|
||||
cwd_path.pop_back();
|
||||
if(!cwd_path.empty())
|
||||
TRACE("Got current working directory %ls\n", cwd_path.c_str());
|
||||
|
||||
if(GetLoadedModuleDirectory(nullptr, proc_path, MAX_PATH))
|
||||
TRACE("Got proc path %ls\n", proc_path);
|
||||
std::wstring proc_path;
|
||||
if(GetLoadedModuleDirectory(nullptr, &proc_path))
|
||||
TRACE("Got proc path %ls\n", proc_path.c_str());
|
||||
|
||||
GetSystemDirectoryW(sys_path, MAX_PATH);
|
||||
len = lstrlenW(sys_path);
|
||||
if(len > 0 && (sys_path[len-1] == '\\' || sys_path[len-1] == '/'))
|
||||
sys_path[len-1] = '\0';
|
||||
TRACE("Got system path %ls\n", sys_path);
|
||||
std::wstring sys_path;
|
||||
if(UINT pathlen{GetSystemDirectoryW(nullptr, 0)})
|
||||
{
|
||||
do {
|
||||
sys_path.resize(pathlen);
|
||||
pathlen = GetSystemDirectoryW(sys_path.data(), pathlen);
|
||||
} while(pathlen >= sys_path.size());
|
||||
sys_path.resize(pathlen);
|
||||
}
|
||||
if(!sys_path.empty() && (sys_path.back() == '\\' || sys_path.back() == '/'))
|
||||
sys_path.pop_back();
|
||||
if(!sys_path.empty())
|
||||
TRACE("Got system path %ls\n", sys_path.c_str());
|
||||
|
||||
/* Don't search the DLL's path if it is the same as the current working
|
||||
* directory, app's path, or system path (don't want to do duplicate
|
||||
* searches, or increase the priority of the app or system path).
|
||||
*/
|
||||
if(dll_path[0] &&
|
||||
(!cwd_path[0] || wcscmp(dll_path, cwd_path) != 0) &&
|
||||
(!proc_path[0] || wcscmp(dll_path, proc_path) != 0) &&
|
||||
(!sys_path[0] || wcscmp(dll_path, sys_path) != 0))
|
||||
if(!dll_path.empty() &&
|
||||
(cwd_path.empty() || dll_path != cwd_path) &&
|
||||
(proc_path.empty() || dll_path != proc_path) &&
|
||||
(sys_path.empty() || dll_path != sys_path))
|
||||
SearchDrivers(dll_path);
|
||||
if(cwd_path[0] &&
|
||||
(!proc_path[0] || wcscmp(cwd_path, proc_path) != 0) &&
|
||||
(!sys_path[0] || wcscmp(cwd_path, sys_path) != 0))
|
||||
if(!cwd_path.empty() &&
|
||||
(proc_path.empty() || cwd_path != proc_path) &&
|
||||
(sys_path.empty() || cwd_path != sys_path))
|
||||
SearchDrivers(cwd_path);
|
||||
if(proc_path[0] && (!sys_path[0] || wcscmp(proc_path, sys_path) != 0))
|
||||
if(!proc_path.empty() && (sys_path.empty() || proc_path != sys_path))
|
||||
SearchDrivers(proc_path);
|
||||
if(sys_path[0])
|
||||
if(!sys_path.empty())
|
||||
SearchDrivers(sys_path);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
PtrIntMap::~PtrIntMap()
|
||||
BOOL APIENTRY DllMain(HINSTANCE, DWORD reason, void*)
|
||||
{
|
||||
std::lock_guard<std::mutex> maplock{mLock};
|
||||
al_free(mKeys);
|
||||
mKeys = nullptr;
|
||||
mValues = nullptr;
|
||||
mSize = 0;
|
||||
mCapacity = 0;
|
||||
}
|
||||
|
||||
ALenum PtrIntMap::insert(void *key, int value)
|
||||
{
|
||||
std::lock_guard<std::mutex> maplock{mLock};
|
||||
auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
|
||||
auto pos = static_cast<ALsizei>(std::distance(mKeys, iter));
|
||||
|
||||
if(pos == mSize || mKeys[pos] != key)
|
||||
switch(reason)
|
||||
{
|
||||
if(mSize == mCapacity)
|
||||
case DLL_PROCESS_ATTACH:
|
||||
if(auto logfname = al::getenv("ALROUTER_LOGFILE"))
|
||||
{
|
||||
void **newkeys{nullptr};
|
||||
ALsizei newcap{mCapacity ? (mCapacity<<1) : 4};
|
||||
if(newcap > mCapacity)
|
||||
newkeys = static_cast<void**>(
|
||||
al_calloc(16, (sizeof(mKeys[0])+sizeof(mValues[0]))*newcap)
|
||||
);
|
||||
if(!newkeys)
|
||||
return AL_OUT_OF_MEMORY;
|
||||
auto newvalues = reinterpret_cast<int*>(&newkeys[newcap]);
|
||||
|
||||
if(mKeys)
|
||||
{
|
||||
std::copy_n(mKeys, mSize, newkeys);
|
||||
std::copy_n(mValues, mSize, newvalues);
|
||||
}
|
||||
al_free(mKeys);
|
||||
mKeys = newkeys;
|
||||
mValues = newvalues;
|
||||
mCapacity = newcap;
|
||||
gsl::owner<std::FILE*> f{fopen(logfname->c_str(), "w")};
|
||||
if(f == nullptr)
|
||||
ERR("Could not open log file: %s\n", logfname->c_str());
|
||||
else
|
||||
LogFile = f;
|
||||
}
|
||||
|
||||
if(pos < mSize)
|
||||
if(auto loglev = al::getenv("ALROUTER_LOGLEVEL"))
|
||||
{
|
||||
std::copy_backward(mKeys+pos, mKeys+mSize, mKeys+mSize+1);
|
||||
std::copy_backward(mValues+pos, mValues+mSize, mValues+mSize+1);
|
||||
char *end = nullptr;
|
||||
long l{strtol(loglev->c_str(), &end, 0)};
|
||||
if(!end || *end != '\0')
|
||||
ERR("Invalid log level value: %s\n", loglev->c_str());
|
||||
else if(l < al::to_underlying(eLogLevel::None)
|
||||
|| l > al::to_underlying(eLogLevel::Trace))
|
||||
ERR("Log level out of range: %s\n", loglev->c_str());
|
||||
else
|
||||
LogLevel = static_cast<eLogLevel>(l);
|
||||
}
|
||||
mSize++;
|
||||
TRACE("Initializing router v0.1-%s %s\n", ALSOFT_GIT_COMMIT_HASH, ALSOFT_GIT_BRANCH);
|
||||
LoadDriverList();
|
||||
|
||||
break;
|
||||
|
||||
case DLL_THREAD_ATTACH:
|
||||
break;
|
||||
case DLL_THREAD_DETACH:
|
||||
break;
|
||||
|
||||
case DLL_PROCESS_DETACH:
|
||||
DriverList.clear();
|
||||
|
||||
if(LogFile)
|
||||
fclose(LogFile);
|
||||
LogFile = nullptr;
|
||||
|
||||
break;
|
||||
}
|
||||
mKeys[pos] = key;
|
||||
mValues[pos] = value;
|
||||
|
||||
return AL_NO_ERROR;
|
||||
}
|
||||
|
||||
int PtrIntMap::removeByKey(void *key)
|
||||
{
|
||||
int ret = -1;
|
||||
|
||||
std::lock_guard<std::mutex> maplock{mLock};
|
||||
auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
|
||||
auto pos = static_cast<ALsizei>(std::distance(mKeys, iter));
|
||||
if(pos < mSize && mKeys[pos] == key)
|
||||
{
|
||||
ret = mValues[pos];
|
||||
if(pos+1 < mSize)
|
||||
{
|
||||
std::copy(mKeys+pos+1, mKeys+mSize, mKeys+pos);
|
||||
std::copy(mValues+pos+1, mValues+mSize, mValues+pos);
|
||||
}
|
||||
mSize--;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int PtrIntMap::lookupByKey(void *key)
|
||||
{
|
||||
int ret = -1;
|
||||
|
||||
std::lock_guard<std::mutex> maplock{mLock};
|
||||
auto iter = std::lower_bound(mKeys, mKeys+mSize, key);
|
||||
auto pos = static_cast<ALsizei>(std::distance(mKeys, iter));
|
||||
if(pos < mSize && mKeys[pos] == key)
|
||||
ret = mValues[pos];
|
||||
|
||||
return ret;
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue