mirror of
https://github.com/mamedev/mame.git
synced 2024-11-16 07:48:32 +01:00
404 lines
10 KiB
C++
404 lines
10 KiB
C++
// Windows/TimeUtils.cpp
|
|
|
|
#include "StdAfx.h"
|
|
|
|
#ifndef _WIN32
|
|
#include <sys/time.h>
|
|
#endif
|
|
|
|
#include "Defs.h"
|
|
#include "TimeUtils.h"
|
|
|
|
namespace NWindows {
|
|
namespace NTime {
|
|
|
|
static const UInt32 kNumTimeQuantumsInSecond = 10000000;
|
|
static const UInt32 kFileTimeStartYear = 1601;
|
|
#if !defined(_WIN32) || defined(UNDER_CE)
|
|
static const UInt32 kDosTimeStartYear = 1980;
|
|
#endif
|
|
static const UInt32 kUnixTimeStartYear = 1970;
|
|
static const UInt64 kUnixTimeOffset =
|
|
(UInt64)60 * 60 * 24 * (89 + 365 * (kUnixTimeStartYear - kFileTimeStartYear));
|
|
static const UInt64 kNumSecondsInFileTime = (UInt64)(Int64)-1 / kNumTimeQuantumsInSecond;
|
|
|
|
bool DosTime_To_FileTime(UInt32 dosTime, FILETIME &ft) throw()
|
|
{
|
|
#if defined(_WIN32) && !defined(UNDER_CE)
|
|
return BOOLToBool(::DosDateTimeToFileTime((UInt16)(dosTime >> 16), (UInt16)(dosTime & 0xFFFF), &ft));
|
|
#else
|
|
ft.dwLowDateTime = 0;
|
|
ft.dwHighDateTime = 0;
|
|
UInt64 res;
|
|
if (!GetSecondsSince1601(kDosTimeStartYear + (dosTime >> 25), (dosTime >> 21) & 0xF, (dosTime >> 16) & 0x1F,
|
|
(dosTime >> 11) & 0x1F, (dosTime >> 5) & 0x3F, (dosTime & 0x1F) * 2, res))
|
|
return false;
|
|
res *= kNumTimeQuantumsInSecond;
|
|
ft.dwLowDateTime = (UInt32)res;
|
|
ft.dwHighDateTime = (UInt32)(res >> 32);
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
static const UInt32 kHighDosTime = 0xFF9FBF7D;
|
|
static const UInt32 kLowDosTime = 0x210000;
|
|
|
|
bool FileTime_To_DosTime(const FILETIME &ft, UInt32 &dosTime) throw()
|
|
{
|
|
#if defined(_WIN32) && !defined(UNDER_CE)
|
|
|
|
WORD datePart, timePart;
|
|
if (!::FileTimeToDosDateTime(&ft, &datePart, &timePart))
|
|
{
|
|
dosTime = (ft.dwHighDateTime >= 0x01C00000) ? kHighDosTime : kLowDosTime;
|
|
return false;
|
|
}
|
|
dosTime = (((UInt32)datePart) << 16) + timePart;
|
|
|
|
#else
|
|
|
|
#define PERIOD_4 (4 * 365 + 1)
|
|
#define PERIOD_100 (PERIOD_4 * 25 - 1)
|
|
#define PERIOD_400 (PERIOD_100 * 4 + 1)
|
|
|
|
unsigned year, mon, day, hour, min, sec;
|
|
UInt64 v64 = ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
|
|
Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
|
|
unsigned temp;
|
|
UInt32 v;
|
|
v64 += (kNumTimeQuantumsInSecond * 2 - 1);
|
|
v64 /= kNumTimeQuantumsInSecond;
|
|
sec = (unsigned)(v64 % 60);
|
|
v64 /= 60;
|
|
min = (unsigned)(v64 % 60);
|
|
v64 /= 60;
|
|
hour = (unsigned)(v64 % 24);
|
|
v64 /= 24;
|
|
|
|
v = (UInt32)v64;
|
|
|
|
year = (unsigned)(kFileTimeStartYear + v / PERIOD_400 * 400);
|
|
v %= PERIOD_400;
|
|
|
|
temp = (unsigned)(v / PERIOD_100);
|
|
if (temp == 4)
|
|
temp = 3;
|
|
year += temp * 100;
|
|
v -= temp * PERIOD_100;
|
|
|
|
temp = v / PERIOD_4;
|
|
if (temp == 25)
|
|
temp = 24;
|
|
year += temp * 4;
|
|
v -= temp * PERIOD_4;
|
|
|
|
temp = v / 365;
|
|
if (temp == 4)
|
|
temp = 3;
|
|
year += temp;
|
|
v -= temp * 365;
|
|
|
|
if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
|
|
ms[1] = 29;
|
|
for (mon = 1; mon <= 12; mon++)
|
|
{
|
|
unsigned s = ms[mon - 1];
|
|
if (v < s)
|
|
break;
|
|
v -= s;
|
|
}
|
|
day = (unsigned)v + 1;
|
|
|
|
dosTime = kLowDosTime;
|
|
if (year < kDosTimeStartYear)
|
|
return false;
|
|
year -= kDosTimeStartYear;
|
|
dosTime = kHighDosTime;
|
|
if (year >= 128)
|
|
return false;
|
|
dosTime = (year << 25) | (mon << 21) | (day << 16) | (hour << 11) | (min << 5) | (sec >> 1);
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
|
|
bool UtcFileTime_To_LocalDosTime(const FILETIME &utc, UInt32 &dosTime) throw()
|
|
{
|
|
FILETIME loc = { 0, 0 };
|
|
const UInt64 u1 = FILETIME_To_UInt64(utc);
|
|
const UInt64 kDelta = ((UInt64)1 << 41); // it's larger than quantums in 1 sec.
|
|
if (u1 >= kDelta)
|
|
{
|
|
if (!FileTimeToLocalFileTime(&utc, &loc))
|
|
loc = utc;
|
|
else
|
|
{
|
|
const UInt64 u2 = FILETIME_To_UInt64(loc);
|
|
const UInt64 delta = u1 < u2 ? (u2 - u1) : (u1 - u2);
|
|
if (delta > kDelta) // if FileTimeToLocalFileTime() overflow, we use UTC time
|
|
loc = utc;
|
|
}
|
|
}
|
|
return FileTime_To_DosTime(loc, dosTime);
|
|
}
|
|
|
|
UInt64 UnixTime_To_FileTime64(UInt32 unixTime) throw()
|
|
{
|
|
return (kUnixTimeOffset + (UInt64)unixTime) * kNumTimeQuantumsInSecond;
|
|
}
|
|
|
|
void UnixTime_To_FileTime(UInt32 unixTime, FILETIME &ft) throw()
|
|
{
|
|
const UInt64 v = UnixTime_To_FileTime64(unixTime);
|
|
ft.dwLowDateTime = (DWORD)v;
|
|
ft.dwHighDateTime = (DWORD)(v >> 32);
|
|
}
|
|
|
|
UInt64 UnixTime64_To_FileTime64(Int64 unixTime) throw()
|
|
{
|
|
return (UInt64)((Int64)kUnixTimeOffset + unixTime) * kNumTimeQuantumsInSecond;
|
|
}
|
|
|
|
|
|
bool UnixTime64_To_FileTime64(Int64 unixTime, UInt64 &fileTime) throw()
|
|
{
|
|
if (unixTime > (Int64)(kNumSecondsInFileTime - kUnixTimeOffset))
|
|
{
|
|
fileTime = (UInt64)(Int64)-1;
|
|
return false;
|
|
}
|
|
if (unixTime < -(Int64)kUnixTimeOffset)
|
|
{
|
|
fileTime = 0;
|
|
return false;
|
|
}
|
|
fileTime = UnixTime64_To_FileTime64(unixTime);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool UnixTime64_To_FileTime(Int64 unixTime, FILETIME &ft) throw()
|
|
{
|
|
UInt64 v;
|
|
const bool res = UnixTime64_To_FileTime64(unixTime, v);
|
|
ft.dwLowDateTime = (DWORD)v;
|
|
ft.dwHighDateTime = (DWORD)(v >> 32);
|
|
return res;
|
|
}
|
|
|
|
|
|
Int64 FileTime_To_UnixTime64(const FILETIME &ft) throw()
|
|
{
|
|
const UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
|
|
return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
|
|
}
|
|
|
|
Int64 FileTime_To_UnixTime64_and_Quantums(const FILETIME &ft, UInt32 &quantums) throw()
|
|
{
|
|
const UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
|
|
quantums = (UInt32)(winTime % kNumTimeQuantumsInSecond);
|
|
return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
|
|
}
|
|
|
|
bool FileTime_To_UnixTime(const FILETIME &ft, UInt32 &unixTime) throw()
|
|
{
|
|
UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
|
|
winTime /= kNumTimeQuantumsInSecond;
|
|
if (winTime < kUnixTimeOffset)
|
|
{
|
|
unixTime = 0;
|
|
return false;
|
|
}
|
|
winTime -= kUnixTimeOffset;
|
|
if (winTime > (UInt32)0xFFFFFFFF)
|
|
{
|
|
unixTime = (UInt32)0xFFFFFFFF;
|
|
return false;
|
|
}
|
|
unixTime = (UInt32)winTime;
|
|
return true;
|
|
}
|
|
|
|
bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
|
|
unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw()
|
|
{
|
|
resSeconds = 0;
|
|
if (year < kFileTimeStartYear || year >= 10000 || month < 1 || month > 12 ||
|
|
day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
|
|
return false;
|
|
UInt32 numYears = year - kFileTimeStartYear;
|
|
UInt32 numDays = numYears * 365 + numYears / 4 - numYears / 100 + numYears / 400;
|
|
Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
|
|
if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
|
|
ms[1] = 29;
|
|
month--;
|
|
for (unsigned i = 0; i < month; i++)
|
|
numDays += ms[i];
|
|
numDays += day - 1;
|
|
resSeconds = ((UInt64)(numDays * 24 + hour) * 60 + min) * 60 + sec;
|
|
return true;
|
|
}
|
|
|
|
|
|
void GetCurUtc_FiTime(CFiTime &ft) throw()
|
|
{
|
|
#ifdef _WIN32
|
|
|
|
// Both variants provide same low resolution on WinXP: about 15 ms.
|
|
// But GetSystemTimeAsFileTime is much faster.
|
|
#ifdef UNDER_CE
|
|
SYSTEMTIME st;
|
|
GetSystemTime(&st);
|
|
SystemTimeToFileTime(&st, &ft);
|
|
#else
|
|
GetSystemTimeAsFileTime(&ft);
|
|
#endif
|
|
|
|
#else
|
|
|
|
FiTime_Clear(ft);
|
|
struct timeval now;
|
|
if (gettimeofday(&now, NULL) == 0)
|
|
{
|
|
ft.tv_sec = now.tv_sec;
|
|
ft.tv_nsec = now.tv_usec * 1000;
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
void GetCurUtcFileTime(FILETIME &ft) throw()
|
|
{
|
|
UInt64 v = 0;
|
|
struct timeval now;
|
|
if (gettimeofday(&now, NULL) == 0)
|
|
{
|
|
v = ((UInt64)now.tv_sec + kUnixTimeOffset) *
|
|
kNumTimeQuantumsInSecond + (UInt64)now.tv_usec * 10;
|
|
}
|
|
ft.dwLowDateTime = (DWORD)v;
|
|
ft.dwHighDateTime = (DWORD)(v >> 32);
|
|
}
|
|
#endif
|
|
|
|
|
|
}}
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
/*
|
|
void FiTime_Normalize_With_Prec(CFiTime &ft, unsigned prec)
|
|
{
|
|
if (prec == k_PropVar_TimePrec_0
|
|
|| prec == k_PropVar_TimePrec_HighPrec
|
|
|| prec >= k_PropVar_TimePrec_100ns)
|
|
return;
|
|
UInt64 v = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
|
|
|
|
int numDigits = (int)prec - (int)k_PropVar_TimePrec_Base;
|
|
UInt32 d;
|
|
if (prec == k_PropVar_TimePrec_DOS)
|
|
{
|
|
// we round up as windows DosDateTimeToFileTime()
|
|
v += NWindows::NTime::kNumTimeQuantumsInSecond * 2 - 1;
|
|
d = NWindows::NTime::kNumTimeQuantumsInSecond * 2;
|
|
}
|
|
else
|
|
{
|
|
if (prec == k_PropVar_TimePrec_Unix)
|
|
numDigits = 0;
|
|
else if (numDigits < 0)
|
|
return;
|
|
d = 1;
|
|
for (unsigned k = numDigits; k < 7; k++)
|
|
d *= 10;
|
|
}
|
|
v /= d;
|
|
v *= d;
|
|
ft.dwLowDateTime = (DWORD)v;
|
|
ft.dwHighDateTime = (DWORD)(v >> 32);
|
|
}
|
|
*/
|
|
|
|
#else
|
|
|
|
/*
|
|
void FiTime_Normalize_With_Prec(CFiTime &ft, unsigned prec)
|
|
{
|
|
if (prec >= k_PropVar_TimePrec_1ns
|
|
|| prec == k_PropVar_TimePrec_HighPrec)
|
|
return;
|
|
|
|
int numDigits = (int)prec - (int)k_PropVar_TimePrec_Base;
|
|
UInt32 d;
|
|
if (prec == k_PropVar_TimePrec_Unix ||
|
|
prec == (int)k_PropVar_TimePrec_Base)
|
|
{
|
|
ft.tv_nsec = 0;
|
|
return;
|
|
}
|
|
if (prec == k_PropVar_TimePrec_DOS)
|
|
{
|
|
// we round up as windows DosDateTimeToFileTime()
|
|
const unsigned sec1 = (ft.tv_sec & 1);
|
|
if (ft.tv_nsec == 0 && sec1 == 0)
|
|
return;
|
|
ft.tv_nsec = 0;
|
|
ft.tv_sec += 2 - sec1;
|
|
return;
|
|
}
|
|
{
|
|
if (prec == k_PropVar_TimePrec_0
|
|
|| numDigits < 0)
|
|
numDigits = 7;
|
|
d = 1;
|
|
for (unsigned k = numDigits; k < 9; k++)
|
|
d *= 10;
|
|
ft.tv_nsec /= d;
|
|
ft.tv_nsec *= d;
|
|
}
|
|
}
|
|
*/
|
|
|
|
int Compare_FiTime(const CFiTime *a1, const CFiTime *a2)
|
|
{
|
|
if (a1->tv_sec < a2->tv_sec) return -1;
|
|
if (a1->tv_sec > a2->tv_sec) return 1;
|
|
if (a1->tv_nsec < a2->tv_nsec) return -1;
|
|
if (a1->tv_nsec > a2->tv_nsec) return 1;
|
|
return 0;
|
|
}
|
|
|
|
bool FILETIME_To_timespec(const FILETIME &ft, timespec &ts)
|
|
{
|
|
UInt32 quantums;
|
|
const Int64 sec = NWindows::NTime::FileTime_To_UnixTime64_and_Quantums(ft, quantums);
|
|
// time_t is long
|
|
const time_t sec2 = (time_t)sec;
|
|
if (sec2 == sec)
|
|
{
|
|
ts.tv_sec = sec2;
|
|
ts.tv_nsec = (long)(quantums * 100);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void FiTime_To_FILETIME_ns100(const CFiTime &ts, FILETIME &ft, unsigned &ns100)
|
|
{
|
|
const UInt64 v = NWindows::NTime::UnixTime64_To_FileTime64(ts.tv_sec) + ((UInt64)ts.tv_nsec / 100);
|
|
ns100 = (unsigned)((UInt64)ts.tv_nsec % 100);
|
|
ft.dwLowDateTime = (DWORD)v;
|
|
ft.dwHighDateTime = (DWORD)(v >> 32);
|
|
}
|
|
|
|
void FiTime_To_FILETIME(const CFiTime &ts, FILETIME &ft)
|
|
{
|
|
const UInt64 v = NWindows::NTime::UnixTime64_To_FileTime64(ts.tv_sec) + ((UInt64)ts.tv_nsec / 100);
|
|
ft.dwLowDateTime = (DWORD)v;
|
|
ft.dwHighDateTime = (DWORD)(v >> 32);
|
|
}
|
|
|
|
#endif
|