Revision control
++ // 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"