mirror of https://github.com/AxioDL/metaforce.git
364 lines
8.9 KiB
C++
364 lines
8.9 KiB
C++
#ifndef _WIN32
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
#if __APPLE__
|
|
#include <mach/mach_time.h>
|
|
#endif
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <cstdarg>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <ctime>
|
|
#ifdef _WIN32
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#include <Windows.h>
|
|
#include <nowide/stackstring.hpp>
|
|
#ifndef _WIN32_IE
|
|
#define _WIN32_IE 0x0400
|
|
#endif
|
|
#include <ShlObj.h>
|
|
#if !defined(S_ISDIR) && defined(S_IFMT) && defined(S_IFDIR)
|
|
#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
|
|
#endif
|
|
#endif
|
|
|
|
#include "Runtime/CBasics.hpp"
|
|
|
|
#include "Runtime/CStopwatch.hpp"
|
|
|
|
#include <logvisor/logvisor.hpp>
|
|
|
|
#if __APPLE__
|
|
static u64 MachToDolphinNum;
|
|
static u64 MachToDolphinDenom;
|
|
#elif _WIN32
|
|
static LARGE_INTEGER PerfFrequency;
|
|
#endif
|
|
|
|
namespace metaforce {
|
|
static logvisor::Module LogModule("metaforce::CBasics");
|
|
void CBasics::Initialize() {
|
|
CStopwatch::InitGlobalTimer();
|
|
#if __APPLE__
|
|
mach_timebase_info_data_t timebase;
|
|
mach_timebase_info(&timebase);
|
|
MachToDolphinNum = GetGCTicksPerSec() * timebase.numer;
|
|
MachToDolphinDenom = 1000000000ull * timebase.denom;
|
|
#elif _WIN32
|
|
QueryPerformanceFrequency(&PerfFrequency);
|
|
#endif
|
|
}
|
|
|
|
u64 CBasics::GetGCTicks() {
|
|
#if __APPLE__
|
|
return mach_absolute_time() * MachToDolphinNum / MachToDolphinDenom;
|
|
#elif __linux__ || __FreeBSD__
|
|
struct timespec tp;
|
|
clock_gettime(CLOCK_MONOTONIC, &tp);
|
|
|
|
return u64((tp.tv_sec * 1000000000ull) + tp.tv_nsec) * GetGCTicksPerSec() / 1000000000ull;
|
|
#elif _WIN32
|
|
LARGE_INTEGER perf;
|
|
QueryPerformanceCounter(&perf);
|
|
perf.QuadPart *= GetGCTicksPerSec();
|
|
perf.QuadPart /= PerfFrequency.QuadPart;
|
|
return perf.QuadPart;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
const u64 CBasics::SECONDS_TO_2000 = 946684800LL;
|
|
const u64 CBasics::TICKS_PER_SECOND = 60750000LL;
|
|
|
|
static struct tm* localtime_r(const time_t& time, struct tm& timeSt, long& gmtOff) {
|
|
#ifndef _WIN32
|
|
auto ret = ::localtime_r(&time, &timeSt);
|
|
if (!ret)
|
|
return nullptr;
|
|
gmtOff = ret->tm_gmtoff;
|
|
return ret;
|
|
#else
|
|
struct tm _gmSt;
|
|
auto reta = localtime_s(&timeSt, &time);
|
|
auto retb = gmtime_s(&_gmSt, &time);
|
|
if (reta || retb)
|
|
return nullptr;
|
|
gmtOff = mktime(&timeSt) - mktime(&_gmSt);
|
|
return &timeSt;
|
|
#endif
|
|
}
|
|
|
|
OSTime CBasics::ToWiiTime(std::chrono::system_clock::time_point time) {
|
|
auto sec = std::chrono::time_point_cast<std::chrono::seconds>(time);
|
|
auto us = std::chrono::duration_cast<std::chrono::microseconds>((time - sec)).count();
|
|
time_t sysTime = std::chrono::system_clock::to_time_t(sec);
|
|
|
|
struct tm _timeSt;
|
|
long gmtOff;
|
|
struct tm* timeSt = localtime_r(sysTime, _timeSt, gmtOff);
|
|
if (!timeSt)
|
|
return 0;
|
|
|
|
/* Returning local */
|
|
return OSTime(TICKS_PER_SECOND * ((sysTime + gmtOff) - SECONDS_TO_2000) + us * TICKS_PER_SECOND / 1000000);
|
|
}
|
|
|
|
std::chrono::system_clock::time_point CBasics::FromWiiTime(OSTime wiiTime) {
|
|
auto div = std::lldiv(SECONDS_TO_2000 + wiiTime, TICKS_PER_SECOND);
|
|
time_t time = time_t(div.quot);
|
|
|
|
time_t sysTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
|
|
struct tm _timeSt;
|
|
long gmtOff;
|
|
struct tm* timeSt = localtime_r(sysTime, _timeSt, gmtOff);
|
|
if (!timeSt)
|
|
return std::chrono::system_clock::from_time_t(0);
|
|
|
|
/* Returning GMT */
|
|
return std::chrono::system_clock::from_time_t(time - gmtOff) +
|
|
std::chrono::microseconds(div.rem * 1000000 / TICKS_PER_SECOND);
|
|
}
|
|
|
|
OSCalendarTime CBasics::ToCalendarTime(std::chrono::system_clock::time_point time) {
|
|
OSCalendarTime ret;
|
|
|
|
auto sec = std::chrono::time_point_cast<std::chrono::seconds>(time);
|
|
auto us = std::chrono::duration_cast<std::chrono::microseconds>((time - sec)).count();
|
|
time_t sysTime = std::chrono::system_clock::to_time_t(sec);
|
|
struct tm _timeSt;
|
|
long gmtOff;
|
|
struct tm* timeSt = localtime_r(sysTime, _timeSt, gmtOff);
|
|
if (!timeSt)
|
|
return {};
|
|
|
|
ret.x0_sec = timeSt->tm_sec;
|
|
ret.x4_min = timeSt->tm_min;
|
|
ret.x8_hour = timeSt->tm_hour;
|
|
ret.xc_mday = timeSt->tm_mday;
|
|
ret.x10_mon = timeSt->tm_mon;
|
|
ret.x14_year = timeSt->tm_year + 1900;
|
|
ret.x18_wday = timeSt->tm_wday;
|
|
ret.x1c_yday = timeSt->tm_yday;
|
|
|
|
auto div = std::ldiv(us, 1000);
|
|
ret.x20_msec = div.quot;
|
|
ret.x24_usec = div.rem;
|
|
|
|
return ret;
|
|
}
|
|
|
|
u16 CBasics::SwapBytes(u16 v) {
|
|
Swap2Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
u32 CBasics::SwapBytes(u32 v) {
|
|
Swap4Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
u64 CBasics::SwapBytes(u64 v) {
|
|
Swap8Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
s16 CBasics::SwapBytes(s16 v) {
|
|
Swap2Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
s32 CBasics::SwapBytes(s32 v) {
|
|
Swap4Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
s64 CBasics::SwapBytes(s64 v) {
|
|
Swap8Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
float CBasics::SwapBytes(float v) {
|
|
Swap4Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
double CBasics::SwapBytes(double v) {
|
|
Swap8Bytes(reinterpret_cast<u8*>(&v));
|
|
return v;
|
|
}
|
|
|
|
void CBasics::Swap2Bytes(u8* v) {
|
|
u16* val = reinterpret_cast<u16*>(v);
|
|
#if __GNUC__
|
|
*val = __builtin_bswap16(*val);
|
|
#elif _WIN32
|
|
*val = _byteswap_ushort(*val);
|
|
#else
|
|
*val = (*val << 8) | ((*val >> 8) & 0xFF);
|
|
#endif
|
|
}
|
|
|
|
void CBasics::Swap4Bytes(u8* v) {
|
|
u32* val = reinterpret_cast<u32*>(v);
|
|
#if __GNUC__
|
|
*val = __builtin_bswap32(*val);
|
|
#elif _WIN32
|
|
*val = _byteswap_ulong(*val);
|
|
#else
|
|
*val = ((*val & 0x0000FFFF) << 16) | ((*val & 0xFFFF0000) >> 16) | ((*val & 0x00FF00FF) << 8) |
|
|
((*val & 0xFF00FF00) >> 8);
|
|
#endif
|
|
}
|
|
|
|
void CBasics::Swap8Bytes(u8* v) {
|
|
u64* val = reinterpret_cast<u64*>(v);
|
|
#if __GNUC__
|
|
*val = __builtin_bswap64(*val);
|
|
#elif _WIN32
|
|
*val = _byteswap_uint64(*val);
|
|
#else
|
|
*val = ((val & 0xFF00000000000000ULL) >> 56) | ((val & 0x00FF000000000000ULL) >> 40) |
|
|
((val & 0x0000FF0000000000ULL) >> 24) | ((val & 0x000000FF00000000ULL) >> 8) |
|
|
((val & 0x00000000FF000000ULL) << 8) | ((val & 0x0000000000FF0000ULL) << 24) |
|
|
((val & 0x000000000000FF00ULL) << 40) | ((val & 0x00000000000000FFULL) << 56);
|
|
#endif
|
|
}
|
|
|
|
int CBasics::Stat(const char* path, Sstat* statOut) {
|
|
#if _WIN32
|
|
size_t pos;
|
|
const nowide::wstackstring wpath(path);
|
|
const wchar_t* wpathP = wpath.get();
|
|
for (pos = 0; pos < 3 && wpathP[pos] != L'\0'; ++pos) {}
|
|
if (pos == 2 && wpathP[1] == L':') {
|
|
wchar_t fixPath[4] = {wpathP[0], L':', L'/', L'\0'};
|
|
return _wstat64(fixPath, statOut);
|
|
}
|
|
return _wstat64(wpath.get(), statOut);
|
|
#else
|
|
return stat(path, statOut);
|
|
#endif
|
|
}
|
|
|
|
/* recursive mkdir */
|
|
int CBasics::RecursiveMakeDir(const char* dir) {
|
|
#if _WIN32
|
|
char tmp[1024];
|
|
|
|
/* copy path */
|
|
std::strncpy(tmp, dir, std::size(tmp));
|
|
const size_t len = std::strlen(tmp);
|
|
if (len >= std::size(tmp)) {
|
|
return -1;
|
|
}
|
|
|
|
/* remove trailing slash */
|
|
if (tmp[len - 1] == '/' || tmp[len - 1] == '\\') {
|
|
tmp[len - 1] = 0;
|
|
}
|
|
|
|
/* recursive mkdir */
|
|
char* p = nullptr;
|
|
Sstat sb;
|
|
for (p = tmp + 1; *p; p++) {
|
|
if (*p == '/' || *p == '\\') {
|
|
*p = 0;
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
const nowide::wstackstring wtmp(tmp);
|
|
if (!CreateDirectoryW(wtmp.get(), nullptr)) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
*p = '/';
|
|
}
|
|
}
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
const nowide::wstackstring wtmp(tmp);
|
|
if (!CreateDirectoryW(wtmp.get(), nullptr)) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
return 0;
|
|
#else
|
|
char tmp[1024];
|
|
|
|
/* copy path */
|
|
std::memset(tmp, 0, std::size(tmp));
|
|
std::strncpy(tmp, dir, std::size(tmp) - 1);
|
|
const size_t len = std::strlen(tmp);
|
|
if (len >= std::size(tmp)) {
|
|
return -1;
|
|
}
|
|
|
|
/* remove trailing slash */
|
|
if (tmp[len - 1] == '/') {
|
|
tmp[len - 1] = 0;
|
|
}
|
|
|
|
/* recursive mkdir */
|
|
char* p = nullptr;
|
|
Sstat sb;
|
|
for (p = tmp + 1; *p; p++) {
|
|
if (*p == '/') {
|
|
*p = 0;
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
if (mkdir(tmp, 0755) < 0) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
*p = '/';
|
|
}
|
|
}
|
|
/* test path */
|
|
if (Stat(tmp, &sb) != 0) {
|
|
/* path does not exist - create directory */
|
|
if (mkdir(tmp, 0755) < 0) {
|
|
return -1;
|
|
}
|
|
} else if (!S_ISDIR(sb.st_mode)) {
|
|
/* not a directory */
|
|
return -1;
|
|
}
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
void CBasics::MakeDir(const char* dir) {
|
|
#if _WIN32
|
|
HRESULT err;
|
|
const nowide::wstackstring wdir(dir);
|
|
if (!CreateDirectoryW(wdir.get(), NULL))
|
|
if ((err = GetLastError()) != ERROR_ALREADY_EXISTS)
|
|
LogModule.report(logvisor::Fatal, FMT_STRING("MakeDir({})"), dir);
|
|
#else
|
|
if (mkdir(dir, 0755))
|
|
if (errno != EEXIST)
|
|
LogModule.report(logvisor::Fatal, FMT_STRING("MakeDir({}): {}"), dir, strerror(errno));
|
|
#endif
|
|
}
|
|
|
|
} // namespace metaforce
|