b8a70e62d5
At the moment, our frame scheduling infrastructure is still heavily based on Xinerama-style rendering. Specifically, we assume that painting is driven by a single timer, etc. This change introduces a new type - RenderLoop. Its main purpose is to drive compositing on a specific output, or in case of X11, on the overlay window. With RenderLoop, compositing is synchronized to vblank events. It exposes the last and the next estimated presentation timestamp. The expected presentation timestamp can be used by effects to ensure that animations are synchronized with the upcoming vblank event. On Wayland, every outputs has its own render loop. On X11, per screen rendering is not possible, therefore the platform exposes the render loop for the overlay window. Ideally, the Scene has to expose the RenderLoop, but as the first step towards better compositing scheduling it's good as is for the time being. The RenderLoop tries to minimize the latency by delaying compositing as close as possible to the next vblank event. One tricky thing about it is that if compositing is too close to the next vblank event, animations may become a little bit choppy. However, increasing the latency reduces the choppiness. Given that, there is no any "silver bullet" solution for the choppiness issue, a new option has been added in the Compositing KCM to specify the amount of latency. By default, it's "Medium," but if a user is not satisfied with the upstream default, they can tweak it.
134 lines
3.6 KiB
C++
134 lines
3.6 KiB
C++
/*
|
|
SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#include "sgivideosyncvsyncmonitor.h"
|
|
#include "logging.h"
|
|
|
|
#include <QX11Info>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
SGIVideoSyncVsyncMonitor *SGIVideoSyncVsyncMonitor::create(QObject *parent)
|
|
{
|
|
const char *extensions = glXQueryExtensionsString(QX11Info::display(),
|
|
QX11Info::appScreen());
|
|
if (!strstr(extensions, "GLX_SGI_video_sync")) {
|
|
return nullptr; // GLX_SGI_video_sync is unsupported.
|
|
}
|
|
|
|
SGIVideoSyncVsyncMonitor *monitor = new SGIVideoSyncVsyncMonitor(parent);
|
|
if (monitor->isValid()) {
|
|
return monitor;
|
|
}
|
|
delete monitor;
|
|
return nullptr;
|
|
}
|
|
|
|
SGIVideoSyncVsyncMonitorHelper::SGIVideoSyncVsyncMonitorHelper(QObject *parent)
|
|
: QObject(parent)
|
|
{
|
|
// Establish a new X11 connection to avoid locking up the main X11 connection.
|
|
m_display = XOpenDisplay(DisplayString(QX11Info::display()));
|
|
if (!m_display) {
|
|
qCDebug(KWIN_X11STANDALONE) << "Failed to establish vsync monitor X11 connection";
|
|
return;
|
|
}
|
|
|
|
const int attribs[] = {
|
|
GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
|
|
0
|
|
};
|
|
|
|
int count;
|
|
GLXFBConfig *configs = glXChooseFBConfig(m_display, DefaultScreen(m_display),
|
|
attribs, &count);
|
|
if (!count) {
|
|
qCDebug(KWIN_X11STANDALONE) << "Couldn't find any suitable FBConfig for vsync monitor";
|
|
return;
|
|
}
|
|
|
|
GLXFBConfig config = configs[0];
|
|
XFree(configs);
|
|
|
|
m_localContext = glXCreateNewContext(m_display, config, GLX_RGBA_TYPE, 0, true);
|
|
if (!m_localContext) {
|
|
qCDebug(KWIN_X11STANDALONE) << "Failed to create opengl context for vsync monitor";
|
|
return;
|
|
}
|
|
|
|
m_drawable = DefaultRootWindow(m_display);
|
|
}
|
|
|
|
SGIVideoSyncVsyncMonitorHelper::~SGIVideoSyncVsyncMonitorHelper()
|
|
{
|
|
if (m_localContext) {
|
|
glXDestroyContext(m_display, m_localContext);
|
|
}
|
|
if (m_display) {
|
|
XCloseDisplay(m_display);
|
|
}
|
|
}
|
|
|
|
bool SGIVideoSyncVsyncMonitorHelper::isValid() const
|
|
{
|
|
return m_display && m_localContext && m_drawable;
|
|
}
|
|
|
|
void SGIVideoSyncVsyncMonitorHelper::poll()
|
|
{
|
|
if (!glXMakeCurrent(m_display, m_drawable, m_localContext)) {
|
|
qCDebug(KWIN_X11STANDALONE) << "Failed to make vsync monitor OpenGL context current";
|
|
emit errorOccurred();
|
|
return;
|
|
}
|
|
|
|
uint count;
|
|
|
|
glXGetVideoSyncSGI(&count);
|
|
glXWaitVideoSyncSGI(2, (count + 1) % 2, &count);
|
|
|
|
// Using monotonic clock is inaccurate, but it's still a pretty good estimate.
|
|
emit vblankOccurred(std::chrono::steady_clock::now().time_since_epoch());
|
|
}
|
|
|
|
SGIVideoSyncVsyncMonitor::SGIVideoSyncVsyncMonitor(QObject *parent)
|
|
: VsyncMonitor(parent)
|
|
, m_thread(new QThread)
|
|
, m_helper(new SGIVideoSyncVsyncMonitorHelper)
|
|
{
|
|
m_helper->moveToThread(m_thread);
|
|
|
|
connect(m_helper, &SGIVideoSyncVsyncMonitorHelper::errorOccurred,
|
|
this, &SGIVideoSyncVsyncMonitor::errorOccurred);
|
|
connect(m_helper, &SGIVideoSyncVsyncMonitorHelper::vblankOccurred,
|
|
this, &SGIVideoSyncVsyncMonitor::vblankOccurred);
|
|
|
|
m_thread->setObjectName(QStringLiteral("vsync event monitor"));
|
|
m_thread->start();
|
|
}
|
|
|
|
SGIVideoSyncVsyncMonitor::~SGIVideoSyncVsyncMonitor()
|
|
{
|
|
m_thread->quit();
|
|
m_thread->wait();
|
|
|
|
delete m_helper;
|
|
delete m_thread;
|
|
}
|
|
|
|
bool SGIVideoSyncVsyncMonitor::isValid() const
|
|
{
|
|
return m_helper->isValid();
|
|
}
|
|
|
|
void SGIVideoSyncVsyncMonitor::arm()
|
|
{
|
|
QMetaObject::invokeMethod(m_helper, &SGIVideoSyncVsyncMonitorHelper::poll);
|
|
}
|
|
|
|
} // namespace KWin
|