citra-mk7/src/common/timer.cpp

208 lines
5.1 KiB
C++
Raw Normal View History

2014-12-17 06:38:14 +01:00
// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <time.h>
#ifdef _WIN32
2016-12-03 21:08:02 +01:00
#include <windows.h>
// windows.h needs to be included before other windows headers
#include <mmsystem.h>
#include <sys/timeb.h>
#else
#include <sys/time.h>
#endif
2015-05-06 09:06:12 +02:00
#include "common/common_types.h"
#include "common/string_util.h"
2015-05-06 09:06:12 +02:00
#include "common/timer.h"
namespace Common {
u32 Timer::GetTimeMs() {
#ifdef _WIN32
2014-04-02 00:20:08 +02:00
return timeGetTime();
#else
2014-04-02 00:20:08 +02:00
struct timeval t;
2014-12-03 19:57:57 +01:00
(void)gettimeofday(&t, nullptr);
2014-04-02 00:20:08 +02:00
return ((u32)(t.tv_sec * 1000 + t.tv_usec / 1000));
#endif
}
// --------------------------------------------
// Initiate, Start, Stop, and Update the time
// --------------------------------------------
// Set initial values for the class
Timer::Timer() : m_LastTime(0), m_StartTime(0), m_Running(false) {
2014-04-02 00:20:08 +02:00
Update();
}
// Write the starting time
void Timer::Start() {
2014-04-02 00:20:08 +02:00
m_StartTime = GetTimeMs();
m_Running = true;
}
// Stop the timer
void Timer::Stop() {
2014-04-02 00:20:08 +02:00
// Write the final time
m_LastTime = GetTimeMs();
m_Running = false;
}
// Update the last time variable
void Timer::Update() {
2014-04-02 00:20:08 +02:00
m_LastTime = GetTimeMs();
// TODO(ector) - QPF
}
// -------------------------------------
// Get time difference and elapsed time
// -------------------------------------
// Get the number of milliseconds since the last Update()
u64 Timer::GetTimeDifference() {
2014-04-02 00:20:08 +02:00
return GetTimeMs() - m_LastTime;
}
// Add the time difference since the last Update() to the starting time.
// This is used to compensate for a paused game.
void Timer::AddTimeDifference() {
2014-04-02 00:20:08 +02:00
m_StartTime += GetTimeDifference();
}
// Get the time elapsed since the Start()
u64 Timer::GetTimeElapsed() {
2014-04-02 00:20:08 +02:00
// If we have not started yet, return 1 (because then I don't
// have to change the FPS calculation in CoreRerecording.cpp .
if (m_StartTime == 0)
return 1;
2014-04-02 00:20:08 +02:00
// Return the final timer time if the timer is stopped
if (!m_Running)
return (m_LastTime - m_StartTime);
2014-04-02 00:20:08 +02:00
return (GetTimeMs() - m_StartTime);
}
// Get the formatted time elapsed since the Start()
std::string Timer::GetTimeElapsedFormatted() const {
2014-04-02 00:20:08 +02:00
// If we have not started yet, return zero
if (m_StartTime == 0)
return "00:00:00:000";
// The number of milliseconds since the start.
// Use a different value if the timer is stopped.
u64 Milliseconds;
if (m_Running)
Milliseconds = GetTimeMs() - m_StartTime;
else
Milliseconds = m_LastTime - m_StartTime;
// Seconds
u32 Seconds = (u32)(Milliseconds / 1000);
// Minutes
u32 Minutes = Seconds / 60;
// Hours
u32 Hours = Minutes / 60;
std::string TmpStr = StringFromFormat("%02i:%02i:%02i:%03i", Hours, Minutes % 60, Seconds % 60,
Milliseconds % 1000);
2014-04-02 00:20:08 +02:00
return TmpStr;
}
// Get current time
void Timer::IncreaseResolution() {
#ifdef _WIN32
2014-04-02 00:20:08 +02:00
timeBeginPeriod(1);
#endif
}
void Timer::RestoreResolution() {
#ifdef _WIN32
2014-04-02 00:20:08 +02:00
timeEndPeriod(1);
#endif
}
// Get the number of seconds since January 1 1970
u64 Timer::GetTimeSinceJan1970() {
2014-04-02 00:20:08 +02:00
time_t ltime;
time(&ltime);
return ((u64)ltime);
}
u64 Timer::GetLocalTimeSinceJan1970() {
2014-04-02 00:20:08 +02:00
time_t sysTime, tzDiff, tzDST;
struct tm* gmTime;
2014-04-02 00:20:08 +02:00
time(&sysTime);
2014-04-02 00:20:08 +02:00
// Account for DST where needed
gmTime = localtime(&sysTime);
if (gmTime->tm_isdst == 1)
2014-04-02 00:20:08 +02:00
tzDST = 3600;
else
tzDST = 0;
2014-04-02 00:20:08 +02:00
// Lazy way to get local time in sec
gmTime = gmtime(&sysTime);
2014-04-02 00:20:08 +02:00
tzDiff = sysTime - mktime(gmTime);
2014-04-02 00:20:08 +02:00
return (u64)(sysTime + tzDiff + tzDST);
}
// Return the current time formatted as Minutes:Seconds:Milliseconds
// in the form 00:00:000.
std::string Timer::GetTimeFormatted() {
2014-04-02 00:20:08 +02:00
time_t sysTime;
struct tm* gmTime;
2014-04-02 00:20:08 +02:00
char tmp[13];
2014-04-02 00:20:08 +02:00
time(&sysTime);
gmTime = localtime(&sysTime);
2014-04-02 00:20:08 +02:00
strftime(tmp, 6, "%M:%S", gmTime);
// Now tack on the milliseconds
#ifdef _WIN32
2014-04-02 00:20:08 +02:00
struct timeb tp;
(void)::ftime(&tp);
return StringFromFormat("%s:%03i", tmp, tp.millitm);
#else
2014-04-02 00:20:08 +02:00
struct timeval t;
2014-12-03 19:57:57 +01:00
(void)gettimeofday(&t, nullptr);
return StringFromFormat("%s:%03d", tmp, (int)(t.tv_usec / 1000));
#endif
}
// Returns a timestamp with decimals for precise time comparisons
// ----------------
double Timer::GetDoubleTime() {
#ifdef _WIN32
2014-04-02 00:20:08 +02:00
struct timeb tp;
(void)::ftime(&tp);
#else
2014-04-02 00:20:08 +02:00
struct timeval t;
2014-12-03 19:57:57 +01:00
(void)gettimeofday(&t, nullptr);
#endif
2014-04-02 00:20:08 +02:00
// Get continuous timestamp
u64 TmpSeconds = Common::Timer::GetTimeSinceJan1970();
2014-04-02 00:20:08 +02:00
// Remove a few years. We only really want enough seconds to make
// sure that we are detecting actual actions, perhaps 60 seconds is
// enough really, but I leave a year of seconds anyway, in case the
// user's clock is incorrect or something like that.
TmpSeconds = TmpSeconds - (38 * 365 * 24 * 60 * 60);
2014-04-02 00:20:08 +02:00
// Make a smaller integer that fits in the double
u32 Seconds = (u32)TmpSeconds;
#ifdef _WIN32
2014-04-02 00:20:08 +02:00
double ms = tp.millitm / 1000.0 / 1000.0;
#else
2014-04-02 00:20:08 +02:00
double ms = t.tv_usec / 1000000.0;
#endif
2014-04-02 00:20:08 +02:00
double TmpTime = Seconds + ms;
2014-04-02 00:20:08 +02:00
return TmpTime;
}
} // Namespace Common