// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/gl/vsync_provider_win.h"
#include <dwmapi.h>
#include "base/numerics/safe_conversions.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "ui/display/win/display_config_helper.h"
#include "ui/gfx/native_widget_types.h"
namespace gl {
namespace {
// Returns a timebase (TimeTicks) & interval (TimeDelta) pair representing last
// vBlank timing and display period (in microseconds) calculated using
// DwmGetCompositionTimingInfo. In cases of failure returns an interval of 0,
// timebase may be 0 in cases where High Resolution Timers are not in use even
// when interval is successfully set.
std::pair<base::TimeTicks, base::TimeDelta> TryGetVSyncParamsFromDwmCompInfo() {
base::TimeTicks timebase;
base::TimeDelta interval;
// Query the DWM timing info first if available. This will provide the most
// precise values.
DWM_TIMING_INFO timing_info;
timing_info.cbSize = sizeof(timing_info);
HRESULT result = ::DwmGetCompositionTimingInfo(NULL, &timing_info);
// DwmGetCompositionTimingInfo returns qpcVBlank & qpcRefreshPeriod as type
// QPC_TIME, which is defined as ULONGLONG. In Chromium time, such as
// base::TimeDelta, is stored as type LONGLONG. In normal operating conditions
// we don't expect DwmGetCompositionTimingInfo to return values larger than
// LLONG_MAX because it is built upon Windows APIs which also treat time as
// type LONGLONG and on a typical system where the QPC interval is 100ns then
// a qpcVBlank time of LLONG_MAX would represent ~29K years. There are cases
// where we can encounter values greater than LLONG_MAX however (see
// https://crbug.com/1499654), so we want to protect against this by falling
// back to another interval querying method.
if (result == S_OK && timing_info.qpcVBlank <= LLONG_MAX &&
timing_info.qpcRefreshPeriod <= LLONG_MAX) {
// Calculate an interval value using the rateRefresh numerator and
// denominator.
base::TimeDelta rate_interval;
if (timing_info.rateRefresh.uiDenominator > 0 &&
timing_info.rateRefresh.uiNumerator > 0) {
// Swap the numerator/denominator to convert frequency to period.
rate_interval = base::Microseconds(timing_info.rateRefresh.uiDenominator *
base::Time::kMicrosecondsPerSecond /
timing_info.rateRefresh.uiNumerator);
}
if (base::TimeTicks::IsHighResolution()) {
// qpcRefreshPeriod is very accurate but noisy, and must be used with
// a high resolution timebase to avoid frequently missing Vsync.
timebase = base::TimeTicks::FromQPCValue(
base::checked_cast<LONGLONG>(timing_info.qpcVBlank));
interval = base::TimeDelta::FromQPCValue(
base::checked_cast<LONGLONG>(timing_info.qpcRefreshPeriod));
// Check for interval values that are impossibly low. A 29 microsecond
// interval was seen (from a qpcRefreshPeriod of 60).
if (interval < base::Milliseconds(1)) {
interval = rate_interval;
}
// Check for the qpcRefreshPeriod interval being improbably small
// compared to the rateRefresh calculated interval, as another
// attempt at detecting driver bugs.
if (!rate_interval.is_zero() && interval < rate_interval / 2) {
interval = rate_interval;
}
} else {
// If FrameTime is not high resolution, we do not want to translate
// the QPC value provided by DWM into the low-resolution timebase,
// which would be error prone and jittery. As a fallback, we assume
// the timebase is zero and use rateRefresh, which may be rounded but
// isn't noisy like qpcRefreshPeriod, instead. The fact that we don't
// have a timebase here may lead to brief periods of jank when our
// scheduling becomes offset from the hardware vsync.
interval = rate_interval;
}
}
return {timebase, interval};
}
// Returns a TimeDelta representing display period (in microseconds) calculated
// using QueryDisplayConfig. In cases of failure returns a TimeDelta of 0.
base::TimeDelta TryGetVsyncIntervalFromDisplayConfig(
gfx::AcceleratedWidget window) {
base::TimeDelta interval;
HMONITOR monitor =
window ? ::MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST)
: ::MonitorFromWindow(nullptr, MONITOR_DEFAULTTOPRIMARY);
if (auto path_info = display::win::GetDisplayConfigPathInfo(monitor);
path_info) {
auto& refresh_rate = path_info->targetInfo.refreshRate;
if (refresh_rate.Denominator != 0 && refresh_rate.Numerator != 0) {
double micro_seconds = base::ClampDiv(
base::ClampMul(base::Time::kMicrosecondsPerSecond,
static_cast<double>(refresh_rate.Denominator)),
static_cast<double>(refresh_rate.Numerator));
interval = base::Microseconds(base::ClampRound<int64_t>(micro_seconds));
}
}
return interval;
}
// Returns a TimeDelta representing display period (in microseconds) calculated
// using EnumDisplaySettings. In cases of failure returns a TimeDelta of 0.
base::TimeDelta TryGetVSyncIntervalFromDisplaySettings(
gfx::AcceleratedWidget window) {
base::TimeDelta interval;
// When DWM compositing is active all displays are normalized to the
// refresh rate of the primary display, and won't composite any faster.
// If DWM compositing is disabled, though, we can use the refresh rates
// reported by each display, which will help systems that have mis-matched
// displays that run at different frequencies.
// NOTE: The EnumDisplaySettings API does not support fractional display
// frequencies, e.g. a display operating at 29.97hz will report a
// frequency of 29hz.
HMONITOR monitor = ::MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST);
MONITORINFOEX monitor_info;
monitor_info.cbSize = sizeof(MONITORINFOEX);
if (::GetMonitorInfo(monitor, &monitor_info)) {
DEVMODE display_info;
display_info.dmSize = sizeof(DEVMODE);
display_info.dmDriverExtra = 0;
if (::EnumDisplaySettings(monitor_info.szDevice, ENUM_CURRENT_SETTINGS,
&display_info) &&
display_info.dmDisplayFrequency > 1) {
interval = base::Microseconds(
(1.0 / base::checked_cast<double>(display_info.dmDisplayFrequency)) *
base::Time::kMicrosecondsPerSecond);
}
}
return interval;
}
} // namespace
VSyncProviderWin::VSyncProviderWin(gfx::AcceleratedWidget window)
: window_(window) {
}
VSyncProviderWin::~VSyncProviderWin() {}
// static
void VSyncProviderWin::InitializeOneOff() {
static bool initialized = false;
if (initialized)
return;
initialized = true;
// Prewarm sandbox
::LoadLibrary(L"dwmapi.dll");
}
void VSyncProviderWin::GetVSyncParameters(UpdateVSyncCallback callback) {
base::TimeTicks timebase;
base::TimeDelta interval;
if (GetVSyncParametersIfAvailable(&timebase, &interval))
std::move(callback).Run(timebase, interval);
}
bool VSyncProviderWin::GetVSyncParametersIfAvailable(
base::TimeTicks* out_timebase,
base::TimeDelta* out_interval) {
TRACE_EVENT0("gpu", "WinVSyncProvider::GetVSyncParameters");
// Prefer getting vsync parameters from DwmCompositionInfo in order to get a
// timebase.
auto [timebase, interval] = TryGetVSyncParamsFromDwmCompInfo();
// If DwmCompositionInfo wasn't available then prefer getting the interval
// from QueryDisplayConfig as it supports fractional refresh rates.
if (interval.is_zero()) {
interval = TryGetVsyncIntervalFromDisplayConfig(window_);
}
if (interval.is_zero()) {
interval = TryGetVSyncIntervalFromDisplaySettings(window_);
}
if (interval.is_zero()) {
return false;
}
*out_timebase = timebase;
*out_interval = interval;
return true;
}
// On Windows versions greater than WIN11_22H2 DWM will execute at the
// refresh rate of the fastest operating display, where previously it
// would always align with the primary monitor. As a result of this, some
// clients of VSyncProviderWin need a way to get an interval that still
// aligns with the Primary monitor (e.g. VSyncThreadWin uses primary monitor
// vblanks for its timings so needs to report intervals that align with that).
// GetVSyncIntervalIfAvailable prioritizes this case, but still allows for
// fallbacks to use DwmCompositionInfo or EnumDisplaySettings if needed.
bool VSyncProviderWin::GetVSyncIntervalIfAvailable(
base::TimeDelta* out_interval) {
TRACE_EVENT0("gpu", "WinVSyncProvider::GetVSyncIntervalIfAvailable");
// Prefer getting vsync parameters from QueryDisplayConfig in order to
// align with window_'s or Primary monitor's vblanks.
base::TimeDelta interval = TryGetVsyncIntervalFromDisplayConfig(window_);
// If QueryDisplayConfig wasn't available then prefer DwmCompositionInfo
// as it supports fractional refresh rates.
if (interval.is_zero()) {
base::TimeTicks timebase;
std::tie(timebase, interval) = TryGetVSyncParamsFromDwmCompInfo();
}
if (interval.is_zero()) {
interval = TryGetVSyncIntervalFromDisplaySettings(window_);
}
if (interval.is_zero()) {
return false;
}
*out_interval = interval;
return true;
}
bool VSyncProviderWin::SupportGetVSyncParametersIfAvailable() const {
return true;
}
bool VSyncProviderWin::IsHWClock() const {
return true;
}
} // namespace gl
Codebase Browser
chromium