Revision control
Copy as Markdown
// Copyright (C) 2021 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
#include "qsurfacecapturegrabber_p.h"
#include <QtCore/qchronotimer.h>
#include <QtCore/qelapsedtimer.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qthread.h>
#include <QtCore/qtimer.h>
#include <mutex>
QT_BEGIN_NAMESPACE
Q_STATIC_LOGGING_CATEGORY(qLcScreenCaptureGrabber, "qt.multimedia.ffmpeg.surfacecapturegrabber");
class QSurfaceCaptureGrabber::GrabbingProfiler
{
public:
auto measure()
{
m_elapsedTimer.start();
return qScopeGuard([&]() {
const auto nsecsElapsed = m_elapsedTimer.nsecsElapsed();
++m_number;
m_wholeTime += nsecsElapsed;
#ifdef DUMP_SCREEN_CAPTURE_PROFILING
qDebug() << "screen grabbing time:" << nsecsElapsed << "avg:" << avgTime()
<< "number:" << m_number;
#endif
});
}
qreal avgTime() const
{
return m_number ? m_wholeTime / (m_number * 1000000.) : 0.;
}
qint64 number() const
{
return m_number;
}
private:
QElapsedTimer m_elapsedTimer;
qint64 m_wholeTime = 0;
qint64 m_number = 0;
};
struct QSurfaceCaptureGrabber::GrabbingContext
{
GrabbingProfiler profiler;
QChronoTimer timer;
QElapsedTimer elapsedTimer;
qint64 lastFrameTime = 0;
};
class QSurfaceCaptureGrabber::GrabbingThread : public QThread
{
public:
GrabbingThread(QSurfaceCaptureGrabber& grabber)
: m_grabber(grabber)
{}
protected:
void run() override
{
m_grabber.initializeGrabbingContext();
if (!m_grabber.isGrabbingContextInitialized())
return;
exec();
m_grabber.finalizeGrabbingContext();
}
private:
QSurfaceCaptureGrabber& m_grabber;
};
QSurfaceCaptureGrabber::QSurfaceCaptureGrabber(ThreadPolicy threadPolicy)
{
setFrameRate(DefaultScreenCaptureFrameRate);
if (threadPolicy == CreateGrabbingThread)
m_thread = std::make_unique<GrabbingThread>(*this);
}
void QSurfaceCaptureGrabber::start()
{
Q_ASSERT(thread()->isCurrentThread());
{
// Locked: pairs with the read in updateTimerInterval().
std::lock_guard locker{ m_mutex };
m_activeRate = m_rate;
}
if (m_thread)
m_thread->start();
else if (!isGrabbingContextInitialized())
initializeGrabbingContext();
}
QSurfaceCaptureGrabber::~QSurfaceCaptureGrabber() = default;
void QSurfaceCaptureGrabber::setFrameRate(std::optional<qreal> rate)
{
if (!rate)
rate = DefaultScreenCaptureFrameRate;
// Bound to a minimum
if (*rate < MinScreenCaptureFrameRate)
rate = MinScreenCaptureFrameRate;
// New rate applies to the next stream only.
Q_ASSERT(thread()->isCurrentThread());
Q_ASSERT(!isGrabbingContextInitialized());
if (m_rate == *rate)
return;
m_rate = *rate;
m_activeRate = *rate; // Also visible pre-start via activeFrameRate().
qCDebug(qLcScreenCaptureGrabber) << "Screen capture rate has been changed:" << *rate;
}
qreal QSurfaceCaptureGrabber::frameRate() const
{
Q_ASSERT(thread()->isCurrentThread());
return m_rate;
}
qreal QSurfaceCaptureGrabber::activeFrameRate() const
{
// Owning thread before start(), grabbing thread after.
return m_activeRate;
}
void QSurfaceCaptureGrabber::stop()
{
if (m_thread)
{
m_thread->quit();
m_thread->wait();
}
else if (isGrabbingContextInitialized())
{
finalizeGrabbingContext();
}
}
void QSurfaceCaptureGrabber::updateError(QPlatformSurfaceCapture::Error error,
const QString &description)
{
std::optional<QPlatformSurfaceCapture::Error> prevError;
{
std::lock_guard locker{ m_mutex };
prevError = std::exchange(m_prevError, error);
}
if (error != QPlatformSurfaceCapture::Error::NoError
|| prevError != QPlatformSurfaceCapture::Error::NoError) {
Q_EMIT errorUpdated(error, description);
}
updateTimerInterval();
}
void QSurfaceCaptureGrabber::updateTimerInterval()
{
using namespace std::chrono;
std::lock_guard locker{ m_mutex };
if (!m_context)
return;
const qreal rate = m_prevError && *m_prevError != QPlatformSurfaceCapture::Error::NoError
? MinScreenCaptureFrameRate
: m_activeRate;
const nanoseconds interval = round<nanoseconds>(nanoseconds(1s) / rate);
if (m_timerInterval == interval)
return;
QChronoTimer *timer = &m_context->timer;
if (timer->thread()->isCurrentThread()) {
timer->setInterval(interval);
m_timerInterval = interval;
} else {
const quint64 generation = m_contextGeneration;
QMetaObject::invokeMethod(timer, [this, interval, generation] {
setTimerInterval(interval, generation);
}, Qt::QueuedConnection);
}
}
void QSurfaceCaptureGrabber::setTimerInterval(std::chrono::nanoseconds interval, quint64 generation)
{
std::lock_guard locker{ m_mutex };
if (!m_context || generation != m_contextGeneration || m_timerInterval == interval)
return;
m_context->timer.setInterval(interval);
m_timerInterval = interval;
}
void QSurfaceCaptureGrabber::initializeGrabbingContext()
{
Q_ASSERT(!isGrabbingContextInitialized());
qCDebug(qLcScreenCaptureGrabber) << "screen capture started";
{
std::lock_guard locker{ m_mutex };
m_context = std::make_unique<GrabbingContext>();
++m_contextGeneration;
m_timerInterval = std::chrono::nanoseconds{ 0 };
}
m_context->timer.setTimerType(Qt::PreciseTimer);
updateTimerInterval();
m_context->elapsedTimer.start();
auto doGrab = [this]() {
auto measure = m_context->profiler.measure();
auto frame = grabFrame();
if (frame.isValid()) {
frame.setStartTime(m_context->lastFrameTime);
frame.setEndTime(m_context->elapsedTimer.nsecsElapsed() / 1000);
m_context->lastFrameTime = frame.endTime();
updateError(QPlatformSurfaceCapture::Error::NoError);
Q_EMIT frameGrabbed(frame);
}
};
doGrab();
m_context->timer.callOnTimeout(&m_context->timer, doGrab);
m_context->timer.start();
}
void QSurfaceCaptureGrabber::finalizeGrabbingContext()
{
Q_ASSERT(isGrabbingContextInitialized());
qCDebug(qLcScreenCaptureGrabber)
<< "end screen capture thread; avg grabbing time:" << m_context->profiler.avgTime()
<< "ms, grabbings number:" << m_context->profiler.number();
{
// Bump the generation first so queued interval updates posted from
// another thread are dropped instead of touching a dead timer.
std::lock_guard locker{ m_mutex };
++m_contextGeneration;
m_timerInterval = std::chrono::nanoseconds{ 0 };
m_context.reset();
}
}
bool QSurfaceCaptureGrabber::isGrabbingContextInitialized() const
{
std::lock_guard locker{ m_mutex };
return m_context != nullptr;
}
void QSurfaceCaptureGrabber::injectContextToGrabbingThread(QObject *context)
{
Q_ASSERT(m_thread);
Q_ASSERT(QThread::currentThread() == context->thread());
context->moveToThread(m_thread.get());
}
QT_END_NAMESPACE
#include "moc_qsurfacecapturegrabber_p.cpp"