Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qsgsoftwarethreadedrenderloop_p.h"
#include "qsgsoftwarecontext_p.h"
#include "qsgsoftwarerenderer_p.h"
#include <private/qsgrenderer_p.h>
#include <private/qquickwindow_p.h>
#include <private/qquickitem_p.h>
#include <private/qquickprofiler_p.h>
#include <private/qquickanimatorcontroller_p.h>
#include <private/qquickprofiler_p.h>
#include <private/qqmldebugserviceinterfaces_p.h>
#include <private/qqmldebugconnector_p.h>
#include <qpa/qplatformbackingstore.h>
#include <QtCore/QQueue>
#include <QtCore/QElapsedTimer>
#include <QtCore/QThread>
#include <QtCore/QMutex>
#include <QtCore/QWaitCondition>
#include <QtGui/QGuiApplication>
#include <QtGui/QBackingStore>
#include <QtQuick/QQuickWindow>
#include <qtquick_tracepoints_p.h>
QT_BEGIN_NAMESPACE
// Used to debug the renderloop logic. Primarily useful for platform integrators
// and when investigating the render loop logic.
Q_STATIC_LOGGING_CATEGORY(QSG_RASTER_LOG_RENDERLOOP, "qt.scenegraph.renderloop")
class QSGSoftwareWindowEvent : public QEvent
{
public:
QSGSoftwareWindowEvent(QQuickWindow *c, QEvent::Type type) : QEvent(type), window(c) { }
QQuickWindow *window;
};
class QSGSoftwareTryReleaseEvent : public QSGSoftwareWindowEvent
{
public:
QSGSoftwareTryReleaseEvent(QQuickWindow *win, bool destroy)
: QSGSoftwareWindowEvent(win, QEvent::Type(WM_TryRelease)), destroying(destroy) { }
bool destroying;
};
class QSGSoftwareSyncEvent : public QSGSoftwareWindowEvent
{
public:
QSGSoftwareSyncEvent(QQuickWindow *c, bool inExpose, bool force)
: QSGSoftwareWindowEvent(c, QEvent::Type(WM_RequestSync))
, size(c->size())
, dpr(c->effectiveDevicePixelRatio())
, syncInExpose(inExpose)
, forceRenderPass(force) { }
QSize size;
float dpr;
bool syncInExpose;
bool forceRenderPass;
};
class QSGSoftwareGrabEvent : public QSGSoftwareWindowEvent
{
public:
QSGSoftwareGrabEvent(QQuickWindow *c, QImage *result)
: QSGSoftwareWindowEvent(c, QEvent::Type(WM_Grab)), image(result) { }
QImage *image;
};
class QSGSoftwareJobEvent : public QSGSoftwareWindowEvent
{
public:
QSGSoftwareJobEvent(QQuickWindow *c, QRunnable *postedJob)
: QSGSoftwareWindowEvent(c, QEvent::Type(WM_PostJob)), job(postedJob) { }
~QSGSoftwareJobEvent() { delete job; }
QRunnable *job;
};
class QSGSoftwareEventQueue : public QQueue<QEvent *>
{
public:
void addEvent(QEvent *e) {
mutex.lock();
enqueue(e);
if (waiting)
condition.wakeOne();
mutex.unlock();
}
QEvent *takeEvent(bool wait) {
mutex.lock();
if (isEmpty() && wait) {
waiting = true;
condition.wait(&mutex);
waiting = false;
}
QEvent *e = dequeue();
mutex.unlock();
return e;
}
bool hasMoreEvents() {
mutex.lock();
bool has = !isEmpty();
mutex.unlock();
return has;
}
private:
QMutex mutex;
QWaitCondition condition;
bool waiting = false;
};
static inline int qsgrl_animation_interval()
{
const qreal refreshRate = QGuiApplication::primaryScreen() ? QGuiApplication::primaryScreen()->refreshRate() : 0;
return refreshRate < 1 ? 16 : int(1000 / refreshRate);
}
class QSGSoftwareRenderThread : public QThread
{
Q_OBJECT
public:
QSGSoftwareRenderThread(QSGSoftwareThreadedRenderLoop *rl, QSGRenderContext *renderContext)
: renderLoop(rl)
{
rc = static_cast<QSGSoftwareRenderContext *>(renderContext);
vsyncDelta = qsgrl_animation_interval();
}
~QSGSoftwareRenderThread()
{
delete rc;
}
bool event(QEvent *e) override;
void run() override;
void syncAndRender();
void sync(bool inExpose);
void requestRepaint()
{
if (sleeping)
stopEventProcessing = true;
if (exposedWindow)
pendingUpdate |= RepaintRequest;
}
void processEventsAndWaitForMore();
void processEvents();
void postEvent(QEvent *e);
enum UpdateRequest {
SyncRequest = 0x01,
RepaintRequest = 0x02,
ExposeRequest = 0x04 | RepaintRequest | SyncRequest
};
QSGSoftwareThreadedRenderLoop *renderLoop;
QSGSoftwareRenderContext *rc;
QAnimationDriver *rtAnim = nullptr;
volatile bool active = false;
uint pendingUpdate = 0;
bool sleeping = false;
bool syncResultedInChanges = false;
float vsyncDelta;
QMutex mutex;
QWaitCondition waitCondition;
QQuickWindow *exposedWindow = nullptr;
QBackingStore *backingStore = nullptr;
bool stopEventProcessing = false;
QSGSoftwareEventQueue eventQueue;
QElapsedTimer renderThrottleTimer;
qint64 syncTime;
qint64 renderTime;
qint64 sinceLastTime;
public slots:
void onSceneGraphChanged() {
syncResultedInChanges = true;
}
};
bool QSGSoftwareRenderThread::event(QEvent *e)
{
switch ((int)e->type()) {
case WM_Obscure:
Q_ASSERT(!exposedWindow || exposedWindow == static_cast<QSGSoftwareWindowEvent *>(e)->window);
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "RT - WM_Obscure" << exposedWindow;
mutex.lock();
if (exposedWindow) {
QQuickWindowPrivate::get(exposedWindow)->fireAboutToStop();
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_Obscure - window removed");
exposedWindow = nullptr;
delete backingStore;
backingStore = nullptr;
}
waitCondition.wakeOne();
mutex.unlock();
return true;
case WM_RequestSync: {
QSGSoftwareSyncEvent *wme = static_cast<QSGSoftwareSyncEvent *>(e);
if (sleeping)
stopEventProcessing = true;
exposedWindow = wme->window;
if (backingStore == nullptr)
backingStore = new QBackingStore(exposedWindow);
if (backingStore->size() != exposedWindow->size())
backingStore->resize(exposedWindow->size());
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "RT - WM_RequestSync" << exposedWindow;
pendingUpdate |= SyncRequest;
if (wme->syncInExpose) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_RequestSync - triggered from expose");
pendingUpdate |= ExposeRequest;
}
if (wme->forceRenderPass) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_RequestSync - repaint regardless");
pendingUpdate |= RepaintRequest;
}
return true;
}
case WM_TryRelease: {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_TryRelease");
mutex.lock();
renderLoop->lockedForSync = true;
QSGSoftwareTryReleaseEvent *wme = static_cast<QSGSoftwareTryReleaseEvent *>(e);
// Only when no windows are exposed anymore or we are shutting down.
if (!exposedWindow || wme->destroying) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_TryRelease - invalidating rc");
if (wme->window) {
QQuickWindowPrivate *wd = QQuickWindowPrivate::get(wme->window);
if (wme->destroying) {
// Bye bye nodes...
wd->cleanupNodesOnShutdown();
}
rc->invalidate();
QCoreApplication::processEvents();
QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
if (wme->destroying)
wd->animationController.reset();
}
if (wme->destroying)
active = false;
if (sleeping)
stopEventProcessing = true;
} else {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_TryRelease - not releasing because window is still active");
}
waitCondition.wakeOne();
renderLoop->lockedForSync = false;
mutex.unlock();
return true;
}
case WM_Grab: {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_Grab");
QSGSoftwareGrabEvent *wme = static_cast<QSGSoftwareGrabEvent *>(e);
Q_ASSERT(wme->window);
Q_ASSERT(wme->window == exposedWindow || !exposedWindow);
mutex.lock();
if (wme->window) {
// Grabbing is generally done by rendering a frame and reading the
// color buffer contents back, without presenting, and then
// creating a QImage from the returned data. It is terribly
// inefficient since it involves a full blocking wait for the GPU.
// However, our hands are tied by the existing, synchronous APIs of
// QQuickWindow and such.
QQuickWindowPrivate *wd = QQuickWindowPrivate::get(wme->window);
auto softwareRenderer = static_cast<QSGSoftwareRenderer*>(wd->renderer);
if (softwareRenderer)
softwareRenderer->setBackingStore(backingStore);
rc->initialize(nullptr);
wd->syncSceneGraph();
rc->endSync();
wd->renderSceneGraph();
*wme->image = backingStore->handle()->toImage();
}
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_Grab - waking gui to handle result");
waitCondition.wakeOne();
mutex.unlock();
return true;
}
case WM_PostJob: {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_PostJob");
QSGSoftwareJobEvent *wme = static_cast<QSGSoftwareJobEvent *>(e);
Q_ASSERT(wme->window == exposedWindow);
if (exposedWindow) {
wme->job->run();
delete wme->job;
wme->job = nullptr;
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - WM_PostJob - job done");
}
return true;
}
default:
break;
}
return QThread::event(e);
}
void QSGSoftwareRenderThread::postEvent(QEvent *e)
{
eventQueue.addEvent(e);
}
void QSGSoftwareRenderThread::processEvents()
{
while (eventQueue.hasMoreEvents()) {
QEvent *e = eventQueue.takeEvent(false);
event(e);
delete e;
}
}
void QSGSoftwareRenderThread::processEventsAndWaitForMore()
{
stopEventProcessing = false;
while (!stopEventProcessing) {
QEvent *e = eventQueue.takeEvent(true);
event(e);
delete e;
}
}
void QSGSoftwareRenderThread::run()
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - run()");
rtAnim = rc->sceneGraphContext()->createAnimationDriver(nullptr);
rtAnim->install();
if (QQmlDebugConnector::service<QQmlProfilerService>())
QQuickProfiler::registerAnimationCallback();
renderThrottleTimer.start();
while (active) {
if (exposedWindow)
syncAndRender();
processEvents();
QCoreApplication::processEvents();
if (pendingUpdate == 0 || !exposedWindow) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - done drawing, sleep");
sleeping = true;
processEventsAndWaitForMore();
sleeping = false;
}
}
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - run() exiting");
delete rtAnim;
rtAnim = nullptr;
rc->moveToThread(renderLoop->thread());
moveToThread(renderLoop->thread());
}
void QSGSoftwareRenderThread::sync(bool inExpose)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - sync");
mutex.lock();
Q_ASSERT_X(renderLoop->lockedForSync, "QSGSoftwareRenderThread::sync()", "sync triggered with gui not locked");
if (exposedWindow) {
QQuickWindowPrivate *wd = QQuickWindowPrivate::get(exposedWindow);
bool hadRenderer = wd->renderer != nullptr;
// If the scene graph was touched since the last sync() make sure it sends the
// changed signal.
if (wd->renderer)
wd->renderer->clearChangedFlag();
rc->initialize(nullptr);
wd->syncSceneGraph();
rc->endSync();
if (!hadRenderer && wd->renderer) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - created renderer");
syncResultedInChanges = true;
connect(wd->renderer, &QSGRenderer::sceneGraphChanged, this,
&QSGSoftwareRenderThread::onSceneGraphChanged, Qt::DirectConnection);
}
// Process deferred deletes now, directly after the sync as deleteLater
// on the GUI must now also have resulted in SG changes and the delete
// is a safe operation.
QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
}
if (!inExpose) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - sync complete, waking gui");
waitCondition.wakeOne();
mutex.unlock();
}
}
void QSGSoftwareRenderThread::syncAndRender()
{
Q_TRACE_SCOPE(QSG_syncAndRender);
Q_TRACE(QSG_sync_entry);
Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphRenderLoopFrame);
QElapsedTimer waitTimer;
waitTimer.start();
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - syncAndRender()");
syncResultedInChanges = false;
QQuickWindowPrivate *wd = QQuickWindowPrivate::get(exposedWindow);
const bool repaintRequested = pendingUpdate & RepaintRequest;
const bool syncRequested = pendingUpdate & SyncRequest;
const bool exposeRequested = (pendingUpdate & ExposeRequest) == ExposeRequest;
pendingUpdate = 0;
emit exposedWindow->beforeFrameBegin();
if (syncRequested)
sync(exposeRequested);
Q_TRACE(QSG_sync_exit);
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopSync);
if (!syncResultedInChanges && !repaintRequested) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - no changes, render aborted");
int waitTime = vsyncDelta - (int) waitTimer.elapsed();
if (waitTime > 0)
msleep(waitTime);
return;
}
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - rendering started");
Q_TRACE(QSG_render_entry);
if (rtAnim->isRunning()) {
wd->animationController->lock();
rtAnim->advance();
wd->animationController->unlock();
}
bool canRender = wd->renderer != nullptr;
if (canRender) {
auto softwareRenderer = static_cast<QSGSoftwareRenderer*>(wd->renderer);
if (softwareRenderer)
softwareRenderer->setBackingStore(backingStore);
wd->renderSceneGraph();
Q_TRACE(QSG_render_exit);
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopRender);
Q_TRACE(QSG_swap_entry);
if (softwareRenderer)
backingStore->flush(softwareRenderer->flushRegion());
// Since there is no V-Sync with QBackingStore, throttle rendering the refresh
// rate of the current screen the window is on.
int blockTime = vsyncDelta - (int) renderThrottleTimer.elapsed();
if (blockTime > 0) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - blocking for %d ms", blockTime);
msleep(blockTime);
}
renderThrottleTimer.start();
wd->fireFrameSwapped();
} else {
Q_TRACE(QSG_render_exit);
Q_QUICK_SG_PROFILE_SKIP(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopSync, 1);
Q_TRACE(QSG_swap_entry);
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - window not ready, skipping render");
}
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - rendering done");
emit exposedWindow->afterFrameEnd();
if (exposeRequested) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "RT - wake gui after initial expose");
waitCondition.wakeOne();
mutex.unlock();
}
Q_TRACE(QSG_swap_exit);
Q_QUICK_SG_PROFILE_END(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopSwap);
}
QSGSoftwareThreadedRenderLoop::WindowData *QSGSoftwareThreadedRenderLoop::windowFor(QQuickWindow *window)
{
for (const auto &t : std::as_const(m_windows)) {
if (t.window == window)
return const_cast<WindowData *>(&t);
}
return nullptr;
}
QSGSoftwareThreadedRenderLoop::QSGSoftwareThreadedRenderLoop()
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "software threaded render loop constructor");
m_sg = new QSGSoftwareContext;
m_anim = m_sg->createAnimationDriver(this);
connect(m_anim, &QAnimationDriver::started, this, &QSGSoftwareThreadedRenderLoop::onAnimationStarted);
connect(m_anim, &QAnimationDriver::stopped, this, &QSGSoftwareThreadedRenderLoop::onAnimationStopped);
m_anim->install();
}
QSGSoftwareThreadedRenderLoop::~QSGSoftwareThreadedRenderLoop()
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "software threaded render loop destructor");
delete m_sg;
}
void QSGSoftwareThreadedRenderLoop::show(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "show" << window;
}
void QSGSoftwareThreadedRenderLoop::hide(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "hide" << window;
if (window->isExposed())
handleObscurity(windowFor(window));
releaseResources(window);
}
void QSGSoftwareThreadedRenderLoop::resize(QQuickWindow *window)
{
if (!window->isExposed() || window->size().isEmpty())
return;
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "resize" << window << window->size();
}
void QSGSoftwareThreadedRenderLoop::windowDestroyed(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "window destroyed" << window;
WindowData *w = windowFor(window);
if (!w)
return;
handleObscurity(w);
handleResourceRelease(w, true);
QSGSoftwareRenderThread *thread = w->thread;
while (thread->isRunning())
QThread::yieldCurrentThread();
Q_ASSERT(thread->thread() == QThread::currentThread());
delete thread;
for (int i = 0; i < m_windows.size(); ++i) {
if (m_windows.at(i).window == window) {
m_windows.removeAt(i);
break;
}
}
// Now that we altered the window list, we may need to stop the animation
// timer even if we didn't via handleObscurity. This covers the case where
// we destroy a visible & exposed QQuickWindow.
startOrStopAnimationTimer();
}
void QSGSoftwareThreadedRenderLoop::exposureChanged(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "exposure changed" << window;
if (window->isExposed()) {
handleExposure(window);
} else {
WindowData *w = windowFor(window);
if (w)
handleObscurity(w);
}
}
QImage QSGSoftwareThreadedRenderLoop::grab(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "grab" << window;
WindowData *w = windowFor(window);
// Have to support invisible (but created()'ed) windows as well.
// Unlike with GL, leaving that case for QQuickWindow to handle is not feasible.
const bool tempExpose = !w;
if (tempExpose) {
handleExposure(window);
w = windowFor(window);
Q_ASSERT(w);
}
if (!w->thread->isRunning())
return QImage();
if (!window->handle())
window->create();
QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
wd->polishItems();
QImage result;
w->thread->mutex.lock();
lockedForSync = true;
w->thread->postEvent(new QSGSoftwareGrabEvent(window, &result));
w->thread->waitCondition.wait(&w->thread->mutex);
lockedForSync = false;
w->thread->mutex.unlock();
result.setDevicePixelRatio(window->effectiveDevicePixelRatio());
if (tempExpose)
handleObscurity(w);
return result;
}
void QSGSoftwareThreadedRenderLoop::update(QQuickWindow *window)
{
WindowData *w = windowFor(window);
if (!w)
return;
if (w->thread == QThread::currentThread()) {
w->thread->requestRepaint();
return;
}
// We set forceRenderPass because we want to make sure the QQuickWindow
// actually does a full render pass after the next sync.
w->forceRenderPass = true;
scheduleUpdate(w);
}
void QSGSoftwareThreadedRenderLoop::maybeUpdate(QQuickWindow *window)
{
WindowData *w = windowFor(window);
if (w)
scheduleUpdate(w);
}
void QSGSoftwareThreadedRenderLoop::handleUpdateRequest(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "handleUpdateRequest" << window;
WindowData *w = windowFor(window);
if (w)
polishAndSync(w, false);
}
QAnimationDriver *QSGSoftwareThreadedRenderLoop::animationDriver() const
{
return m_anim;
}
QSGContext *QSGSoftwareThreadedRenderLoop::sceneGraphContext() const
{
return m_sg;
}
QSGRenderContext *QSGSoftwareThreadedRenderLoop::createRenderContext(QSGContext *) const
{
return m_sg->createRenderContext();
}
void QSGSoftwareThreadedRenderLoop::releaseResources(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "releaseResources" << window;
WindowData *w = windowFor(window);
if (w)
handleResourceRelease(w, false);
}
void QSGSoftwareThreadedRenderLoop::postJob(QQuickWindow *window, QRunnable *job)
{
WindowData *w = windowFor(window);
if (w && w->thread && w->thread->exposedWindow)
w->thread->postEvent(new QSGSoftwareJobEvent(window, job));
else
delete job;
}
QSurface::SurfaceType QSGSoftwareThreadedRenderLoop::windowSurfaceType() const
{
return QSurface::RasterSurface;
}
bool QSGSoftwareThreadedRenderLoop::interleaveIncubation() const
{
bool somethingVisible = false;
for (const WindowData &w : m_windows) {
if (w.window->isVisible() && w.window->isExposed()) {
somethingVisible = true;
break;
}
}
return somethingVisible && m_anim->isRunning();
}
int QSGSoftwareThreadedRenderLoop::flags() const
{
return SupportsGrabWithoutExpose;
}
bool QSGSoftwareThreadedRenderLoop::event(QEvent *e)
{
if (e->type() == QEvent::Timer) {
QTimerEvent *te = static_cast<QTimerEvent *>(e);
if (te->timerId() == animationTimer) {
m_anim->advance();
emit timeToIncubate();
return true;
}
}
return QObject::event(e);
}
void QSGSoftwareThreadedRenderLoop::onAnimationStarted()
{
startOrStopAnimationTimer();
for (const WindowData &w : std::as_const(m_windows))
w.window->requestUpdate();
}
void QSGSoftwareThreadedRenderLoop::onAnimationStopped()
{
startOrStopAnimationTimer();
}
void QSGSoftwareThreadedRenderLoop::startOrStopAnimationTimer()
{
int exposedWindowCount = 0;
const WindowData *exposed = nullptr;
for (int i = 0; i < m_windows.size(); ++i) {
const WindowData &w(m_windows[i]);
if (w.window->isVisible() && w.window->isExposed()) {
++exposedWindowCount;
exposed = &w;
}
}
if (animationTimer && (exposedWindowCount == 1 || !m_anim->isRunning())) {
killTimer(animationTimer);
animationTimer = 0;
// If animations are running, make sure we keep on animating
if (m_anim->isRunning())
exposed->window->requestUpdate();
} else if (!animationTimer && exposedWindowCount != 1 && m_anim->isRunning()) {
animationTimer = startTimer(qsgrl_animation_interval());
}
}
void QSGSoftwareThreadedRenderLoop::handleExposure(QQuickWindow *window)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "handleExposure" << window;
WindowData *w = windowFor(window);
if (!w) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "adding window to list");
WindowData win;
win.window = window;
QSGRenderContext *rc = QQuickWindowPrivate::get(window)->context; // will transfer ownership
win.thread = new QSGSoftwareRenderThread(this, rc);
win.updateDuringSync = false;
win.forceRenderPass = true; // also covered by polishAndSync(inExpose=true), but doesn't hurt
m_windows.append(win);
w = &m_windows.last();
}
// set this early as we'll be rendering shortly anyway and this avoids
// special casing exposure in polishAndSync.
w->thread->exposedWindow = window;
if (w->window->size().isEmpty()
|| (w->window->isTopLevel() && !w->window->geometry().intersects(w->window->screen()->availableGeometry()))) {
#ifndef QT_NO_DEBUG
qWarning().noquote().nospace() << "QSGSotwareThreadedRenderLoop: expose event received for window "
<< w->window << " with invalid geometry: " << w->window->geometry()
<< " on " << w->window->screen();
#endif
}
if (!w->window->handle())
w->window->create();
// Start render thread if it is not running
if (!w->thread->isRunning()) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "starting render thread");
// Push a few things to the render thread.
QQuickAnimatorController *controller
= QQuickWindowPrivate::get(w->window)->animationController.get();
if (controller->thread() != w->thread)
controller->moveToThread(w->thread);
if (w->thread->thread() == QThread::currentThread()) {
w->thread->rc->moveToThread(w->thread);
w->thread->moveToThread(w->thread);
}
w->thread->active = true;
w->thread->start();
if (!w->thread->isRunning())
qFatal("Render thread failed to start, aborting application.");
}
polishAndSync(w, true);
startOrStopAnimationTimer();
}
void QSGSoftwareThreadedRenderLoop::handleObscurity(QSGSoftwareThreadedRenderLoop::WindowData *w)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "handleObscurity" << w->window;
if (w->thread->isRunning()) {
w->thread->mutex.lock();
w->thread->postEvent(new QSGSoftwareWindowEvent(w->window, QEvent::Type(WM_Obscure)));
w->thread->waitCondition.wait(&w->thread->mutex);
w->thread->mutex.unlock();
}
startOrStopAnimationTimer();
}
void QSGSoftwareThreadedRenderLoop::scheduleUpdate(QSGSoftwareThreadedRenderLoop::WindowData *w)
{
if (!QCoreApplication::instance())
return;
if (!w || !w->thread->isRunning())
return;
QThread *current = QThread::currentThread();
if (current != QCoreApplication::instance()->thread() && (current != w->thread || !lockedForSync)) {
qWarning() << "Updates can only be scheduled from GUI thread or from QQuickItem::updatePaintNode()";
return;
}
if (current == w->thread) {
w->updateDuringSync = true;
return;
}
w->window->requestUpdate();
}
void QSGSoftwareThreadedRenderLoop::handleResourceRelease(QSGSoftwareThreadedRenderLoop::WindowData *w, bool destroying)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "handleResourceRelease" << (destroying ? "destroying" : "hide/releaseResources") << w->window;
w->thread->mutex.lock();
if (w->thread->isRunning() && w->thread->active) {
QQuickWindow *window = w->window;
// Note that window->handle() is typically null by this time because
// the platform window is already destroyed. This should not be a
// problem for the D3D cleanup.
w->thread->postEvent(new QSGSoftwareTryReleaseEvent(window, destroying));
w->thread->waitCondition.wait(&w->thread->mutex);
// Avoid a shutdown race condition.
// If SG is invalidated and 'active' becomes false, the thread's run()
// method will exit. handleExposure() relies on QThread::isRunning() (because it
// potentially needs to start the thread again) and our mutex cannot be used to
// track the thread stopping, so we wait a few nanoseconds extra so the thread
// can exit properly.
if (!w->thread->active)
w->thread->wait();
}
w->thread->mutex.unlock();
}
void QSGSoftwareThreadedRenderLoop::polishAndSync(QSGSoftwareThreadedRenderLoop::WindowData *w, bool inExpose)
{
qCDebug(QSG_RASTER_LOG_RENDERLOOP) << "polishAndSync" << (inExpose ? "(in expose)" : "(normal)") << w->window;
QQuickWindow *window = w->window;
if (!w->thread || !w->thread->exposedWindow) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "polishAndSync - not exposed, abort");
return;
}
// Flush pending touch events.
QQuickWindowPrivate::get(window)->deliveryAgentPrivate()->flushFrameSynchronousEvents(window);
// The delivery of the event might have caused the window to stop rendering
w = windowFor(window);
if (!w || !w->thread || !w->thread->exposedWindow) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "polishAndSync - removed after touch event flushing, abort");
return;
}
Q_TRACE_SCOPE(QSG_polishAndSync);
Q_TRACE(QSG_polishItems_entry);
Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphPolishAndSync);
QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
wd->polishItems();
Q_TRACE(QSG_polishItems_exit);
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphPolishAndSync,
QQuickProfiler::SceneGraphPolishAndSyncPolish);
Q_TRACE(QSG_sync_entry);
w->updateDuringSync = false;
emit window->afterAnimating();
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "polishAndSync - lock for sync");
w->thread->mutex.lock();
lockedForSync = true;
w->thread->postEvent(new QSGSoftwareSyncEvent(window, inExpose, w->forceRenderPass));
w->forceRenderPass = false;
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "polishAndSync - wait for sync");
Q_TRACE(QSG_sync_exit);
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphPolishAndSync,
QQuickProfiler::SceneGraphPolishAndSyncWait);
Q_TRACE(QSG_wait_entry);
w->thread->waitCondition.wait(&w->thread->mutex);
lockedForSync = false;
w->thread->mutex.unlock();
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "polishAndSync - unlock after sync");
Q_TRACE(QSG_wait_exit);
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphPolishAndSync,
QQuickProfiler::SceneGraphPolishAndSyncSync);
Q_TRACE(QSG_animations_entry);
if (!animationTimer && m_anim->isRunning()) {
qCDebug(QSG_RASTER_LOG_RENDERLOOP, "polishAndSync - advancing animations");
m_anim->advance();
// We need to trigger another sync to keep animations running...
w->window->requestUpdate();
emit timeToIncubate();
} else if (w->updateDuringSync) {
w->window->requestUpdate();
}
Q_TRACE(QSG_animations_exit);
Q_QUICK_SG_PROFILE_END(QQuickProfiler::SceneGraphPolishAndSync,
QQuickProfiler::SceneGraphPolishAndSyncAnimations);
}
QT_END_NAMESPACE
#include "qsgsoftwarethreadedrenderloop.moc"
#include "moc_qsgsoftwarethreadedrenderloop_p.cpp"