aiden
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Qt: Rename background controller poll to idle update

Browse Source 
Been that for a while anyway.
pull/3782/head
Stenzek 2 months ago
parent fa5e11116f
commit 30fa5b4c4e
No known key found for this signature in database
2 changed files with 53 additions and 52 deletions
Show Stats Download Patch File Download Diff File

90
src/duckstation-qt/qthost.cpp
Unescape Escape View File

@ -105,17 +105,17 @@ Q_IMPORT_PLUGIN(SVGImageHandlerPlugin);
static constexpr u32 SETTINGS_SAVE_DELAY = 1000;
/// Interval at which the controllers are polled when the system is not active.
static constexpr int BACKGROUND_CONTROLLER_POLLING_INTERVAL_WITH_DEVICES = 100;
static constexpr int BACKGROUND_CONTROLLER_POLLING_INTERVAL_WITHOUT_DEVICES = 1000;
static constexpr int IDLE_UPDATE_INTERVAL_WITH_CONTROLLERS = 100;
static constexpr int IDLE_UPDATE_INTERVAL_WITHOUT_CONTROLLERS = 1000;
/// Poll at half the vsync rate for FSUI to reduce the chance of getting a press+release in the same frame.
static constexpr int FULLSCREEN_UI_CONTROLLER_POLLING_INTERVAL = 8;
static constexpr int IDLE_UPDATE_INTERVAL_WITH_FULLSCREEN_UI = 8;
/// Poll at 10ms when downloads are active to ensure the speed is not impacted.
static constexpr int DOWNLOAD_CONTROLLER_POLLING_INTERVAL = 10;
static constexpr int IDLE_UPDATE_INTERVAL_WHILE_DOWNLOADING = 10;
/// Poll at 1ms when running GDB server. We can get rid of this once we move networking to its own thread.
static constexpr int GDB_SERVER_POLLING_INTERVAL = 1;
static constexpr int IDLE_UPDATE_INTERVAL_WITH_GDB_CLIENTS = 1;
//////////////////////////////////////////////////////////////////////////
// Local function declarations
@ -1335,7 +1335,7 @@ void Host::OnSystemStarting()
void Host::OnSystemStarted()
{
g_core_thread->stopBackgroundControllerPollTimer();
g_core_thread->stopIdleUpdateTimer();
g_core_thread->wakeThread();
emit g_core_thread->systemStarted();
@ -1344,7 +1344,7 @@ void Host::OnSystemStarted()
void Host::OnSystemPaused()
{
emit g_core_thread->systemPaused();
g_core_thread->startBackgroundControllerPollTimer();
g_core_thread->startIdleUpdateTimer();
}
void Host::OnSystemResumed()
@ -1352,7 +1352,7 @@ void Host::OnSystemResumed()
emit g_core_thread->systemResumed();
g_core_thread->wakeThread();
g_core_thread->stopBackgroundControllerPollTimer();
g_core_thread->stopIdleUpdateTimer();
}
void Host::OnSystemStopping()
@ -1363,7 +1363,7 @@ void Host::OnSystemStopping()
void Host::OnSystemDestroyed()
{
g_core_thread->resetPerformanceCounters();
g_core_thread->startBackgroundControllerPollTimer();
g_core_thread->startIdleUpdateTimer();
emit g_core_thread->systemDestroyed();
}
@ -2086,60 +2086,60 @@ void CoreThread::processAuxiliaryRenderWindowInputEvent(void* userdata, quint32
});
}
void CoreThread::createBackgroundControllerPollTimer()
void CoreThread::createIdleUpdateTimer()
{
DebugAssert(!m_background_controller_polling_timer);
m_background_controller_polling_timer = new QTimer(this);
m_background_controller_polling_timer->setSingleShot(false);
m_background_controller_polling_timer->setTimerType(Qt::CoarseTimer);
connect(m_background_controller_polling_timer, &QTimer::timeout, &Core::IdleUpdate);
DebugAssert(!m_idle_update_timer);
m_idle_update_timer = new QTimer(this);
m_idle_update_timer->setSingleShot(false);
m_idle_update_timer->setTimerType(Qt::CoarseTimer);
connect(m_idle_update_timer, &QTimer::timeout, &Core::IdleUpdate);
}
void CoreThread::destroyBackgroundControllerPollTimer()
void CoreThread::destroyIdleUpdateTimer()
{
delete m_background_controller_polling_timer;
m_background_controller_polling_timer = nullptr;
delete m_idle_update_timer;
m_idle_update_timer = nullptr;
}
void CoreThread::startBackgroundControllerPollTimer()
void CoreThread::startIdleUpdateTimer()
{
if (m_background_controller_polling_timer->isActive())
if (m_idle_update_timer->isActive())
{
updateBackgroundControllerPollInterval();
updateIdleTimerInterval();
return;
}
const int interval = getBackgroundControllerPollInterval();
DEV_LOG("Starting background controller polling timer with interval {} ms", interval);
m_background_controller_polling_timer->start(interval);
m_idle_update_timer->start(interval);
}
void CoreThread::stopBackgroundControllerPollTimer()
void CoreThread::stopIdleUpdateTimer()
{
if (!m_background_controller_polling_timer->isActive())
if (!m_idle_update_timer->isActive())
return;
DEV_LOG("Stopping background controller polling timer");
m_background_controller_polling_timer->stop();
m_idle_update_timer->stop();
}
void CoreThread::updateBackgroundControllerPollInterval()
void CoreThread::updateIdleTimerInterval()
{
if (!isCurrentThread())
{
QMetaObject::invokeMethod(this, &CoreThread::updateBackgroundControllerPollInterval, Qt::QueuedConnection);
QMetaObject::invokeMethod(this, &CoreThread::updateIdleTimerInterval, Qt::QueuedConnection);
return;
}
if (!m_background_controller_polling_timer || !m_background_controller_polling_timer->isActive())
if (!m_idle_update_timer || !m_idle_update_timer->isActive())
return;
const int current_interval = m_background_controller_polling_timer->interval();
const int current_interval = m_idle_update_timer->interval();
const int new_interval = getBackgroundControllerPollInterval();
if (current_interval != new_interval)
{
WARNING_LOG("Changed background polling interval from {} ms to {} ms", current_interval, new_interval);
m_background_controller_polling_timer->setInterval(new_interval);
WARNING_LOG("Changed idle update interval from {} ms to {} ms", current_interval, new_interval);
m_idle_update_timer->setInterval(new_interval);
}
}
@ -2147,17 +2147,17 @@ int CoreThread::getBackgroundControllerPollInterval() const
{
#ifdef ENABLE_GDB_SERVER
if (GDBServer::HasAnyClients())
return GDB_SERVER_POLLING_INTERVAL;
return IDLE_UPDATE_INTERVAL_WITH_GDB_CLIENTS;
#endif
if (m_video_thread_run_idle)
return FULLSCREEN_UI_CONTROLLER_POLLING_INTERVAL;
return IDLE_UPDATE_INTERVAL_WITH_FULLSCREEN_UI;
else if (m_http_downloader_active)
return DOWNLOAD_CONTROLLER_POLLING_INTERVAL;
return IDLE_UPDATE_INTERVAL_WHILE_DOWNLOADING;
else if (InputManager::GetPollableDeviceCount() > 0)
return BACKGROUND_CONTROLLER_POLLING_INTERVAL_WITH_DEVICES;
return IDLE_UPDATE_INTERVAL_WITH_CONTROLLERS;
else
return BACKGROUND_CONTROLLER_POLLING_INTERVAL_WITHOUT_DEVICES;
return IDLE_UPDATE_INTERVAL_WITHOUT_CONTROLLERS;
}
void CoreThread::setHTTPDownloaderActive(bool active)
@ -2170,7 +2170,7 @@ void CoreThread::setHTTPDownloaderActive(bool active)
DEV_LOG("HTTP Downloader now {}", active ? "active" : "inactive");
m_http_downloader_active = active;
updateBackgroundControllerPollInterval();
updateIdleTimerInterval();
}
void CoreThread::setVideoThreadRunIdle(bool active)
@ -2188,10 +2188,10 @@ void CoreThread::setVideoThreadRunIdle(bool active)
m_event_loop->quit();
// adjust the timer speed to pick up controller input faster
if (!m_background_controller_polling_timer->isActive())
if (!m_idle_update_timer->isActive())
return;
g_core_thread->updateBackgroundControllerPollInterval();
g_core_thread->updateIdleTimerInterval();
}
void CoreThread::updateFullscreenUITheme()
@ -2214,7 +2214,7 @@ void Host::OnHTTPDownloaderActiveChanged(bool active)
void Host::OnGDBServerActiveClientsChanged(bool has_clients)
{
g_core_thread->updateBackgroundControllerPollInterval();
g_core_thread->updateIdleTimerInterval();
}
void CoreThread::stop()
@ -2262,8 +2262,8 @@ void CoreThread::run()
m_input_device_list_model->enumerateDevices();
// start background input polling
createBackgroundControllerPollTimer();
startBackgroundControllerPollTimer();
createIdleUpdateTimer();
startIdleUpdateTimer();
// main loop
while (!m_shutdown_flag)
@ -2289,7 +2289,7 @@ void CoreThread::run()
if (System::IsValid())
System::ShutdownSystem(false);
destroyBackgroundControllerPollTimer();
destroyIdleUpdateTimer();
// and tidy up everything left
Core::CoreThreadShutdown();
@ -2999,14 +2999,14 @@ void Host::OnInputDeviceConnected(InputBindingKey key, std::string_view identifi
QMetaObject::invokeMethod(g_core_thread->getInputDeviceListModel(), &InputDeviceListModel::onDeviceConnected,
Qt::QueuedConnection, key, QtUtils::StringViewToQString(identifier),
QtUtils::StringViewToQString(device_name), qeffect_list);
g_core_thread->updateBackgroundControllerPollInterval();
g_core_thread->updateIdleTimerInterval();
}
void Host::OnInputDeviceDisconnected(InputBindingKey key, std::string_view identifier)
{
QMetaObject::invokeMethod(g_core_thread->getInputDeviceListModel(), &InputDeviceListModel::onDeviceDisconnected,
Qt::QueuedConnection, key, QtUtils::StringViewToQString(identifier));
g_core_thread->updateBackgroundControllerPollInterval();
g_core_thread->updateIdleTimerInterval();
}
void Host::AddFixedInputBindings(const SettingsInterface& si)

15
src/duckstation-qt/qthost.h
Unescape Escape View File

@ -86,9 +86,9 @@ public:
void connectRenderWindowSignals(DisplayWidget* widget);
void releaseRenderWindow();
void startBackgroundControllerPollTimer();
void stopBackgroundControllerPollTimer();
void updateBackgroundControllerPollInterval();
void startIdleUpdateTimer();
void stopIdleUpdateTimer();
void updateIdleTimerInterval();
void wakeThread();
void updatePerformanceCounters(const GPUBackend* gpu_backend);
@ -123,7 +123,8 @@ Q_SIGNALS:
void mouseModeRequested(bool relative, bool hide_cursor, bool ignore_double_click);
void fullscreenUIStartedOrStopped(bool running);
void achievementsLoginRequested(Achievements::LoginRequestReason reason);
void achievementsLoginSuccess(const QString& username, quint32 points, quint32 casual_points, quint32 unread_messages);
void achievementsLoginSuccess(const QString& username, quint32 points, quint32 casual_points,
quint32 unread_messages);
void achievementsActiveChanged(bool active);
void achievementsHardcoreModeChanged(bool enabled);
void mediaCaptureStarted(MediaCaptureMode mode);
@ -202,8 +203,8 @@ private:
void processAuxiliaryRenderWindowInputEvent(void* userdata, quint32 event, quint32 param1, quint32 param2,
quint32 param3);
void createBackgroundControllerPollTimer();
void destroyBackgroundControllerPollTimer();
void createIdleUpdateTimer();
void destroyIdleUpdateTimer();
void bootOrLoadState(std::string path);
@ -212,7 +213,7 @@ private:
QThread* m_ui_thread;
QEventLoop* m_event_loop = nullptr;
QTimer* m_background_controller_polling_timer = nullptr;
QTimer* m_idle_update_timer = nullptr;
std::unique_ptr<InputDeviceListModel> m_input_device_list_model;
bool m_shutdown_flag = false;

Write Preview
Loading…
Cancel
Save