Revision control
++ // Copyright (C) 2026 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 "qsckwindowcapture_p.h"
++
++ #include <QtCore/qthread.h>
++ #include <QtCore/private/qcore_mac_p.h>
++
++ #include <QtFFmpegMediaPluginImpl/private/qffmpegmediacapturesession_p.h>
++ #include <QtFFmpegMediaPluginImpl/private/qmacscreencapturekit_p.h>
++
++ #include <QtMultimedia/private/qmultimedia_ranges_p.h>
++ #include <QtMultimedia/private/qcapturablewindow_p.h>
++ #include <QtMultimedia/private/qvideoframe_p.h>
++
++ #define AVMediaType XAVMediaType
++ extern "C" {
++ #include <libavutil/hwcontext_videotoolbox.h>
++ }
++ #undef AVMediaType
++
++ namespace ranges = QtMultimediaPrivate::ranges;
++ using namespace Qt::Literals::StringLiterals;
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QFFmpeg {
++
++ namespace {
++
++ [[nodiscard]] q23::expected<AVFScopedPointer<SCWindow>, QString> findScWindow(CGWindowID input)
++ {
++ // Do a blocking enumeration of capturable items.
++ q23::expected<QMacScreenCaptureKit::CapturableItems, QString> enumerateResult =
++ QMacScreenCaptureKit::enumerateCapturableItems()
++ .get();
++
++ if (!enumerateResult)
++ return q23::unexpected(enumerateResult.error());
++
++ const std::vector<AVFScopedPointer<SCWindow>> &windows = enumerateResult->windows;
++ auto it = ranges::find_if(
++ windows,
++ [&](const AVFScopedPointer<SCWindow> &item) {
++ return item.data().windowID == input;
++ });
++
++ if (it == windows.end())
++ return q23::unexpected(u"Window not found"_s);
++
++ // AVFScopedPointer doesn't have shared-ptr semantics, force a reference increment.
++ return AVFScopedPointer<SCWindow>{ [it->data() retain] };
++ }
++
++ void setupQMacScreenCaptureKitConnections(
++ QSckWindowCapture &windowCapture,
++ const QMacScreenCaptureKit &macScreenCaptureKit)
++ {
++ // Direct connection so application developers can respond to frame directly
++ // from background thread.
++ // Remaining frames are always flushed whenever we go inactive, as a result
++ // of QMacScreenCaptureKit doing so in the destructor. Because we flush,
++ // we trust the application developer to not block the background thread.
++ QObject::connect(
++ &macScreenCaptureKit,
++ &QMacScreenCaptureKit::newVideoFrameGenerated,
++ &windowCapture,
++ [&windowCapture](QMacScreenCaptureKit::StreamId, QVideoFrame videoFrame) {
++ Q_EMIT windowCapture.newVideoFrame(videoFrame);
++ },
++ Qt::DirectConnection);
++
++ QObject::connect(
++ &macScreenCaptureKit,
++ &QMacScreenCaptureKit::newVideoFrameGenerated,
++ &windowCapture,
++ [&windowCapture](QMacScreenCaptureKit::StreamId streamId, QVideoFrame newFrame) {
++ windowCapture.onNewFrameFormatReceived(streamId, newFrame.surfaceFormat());
++ },
++ Qt::QueuedConnection);
++
++ QObject::connect(
++ &macScreenCaptureKit,
++ &QMacScreenCaptureKit::streamStoppedWithError,
++ &windowCapture,
++ &QSckWindowCapture::onStreamStoppedWithErrorEvent,
++ Qt::QueuedConnection);
++ }
++
++ } // Anonymous namespace
++
++ QSckWindowCapture::QSckWindowCapture() : QPlatformSurfaceCapture(WindowSource{})
++ {
++ }
++
++ void QSckWindowCapture::setCaptureSession(QPlatformMediaCaptureSession *sessionIn)
++ {
++ if (!sessionIn) {
++ m_session = nullptr;
++ return;
++ }
++
++ auto session = qobject_cast<QFFmpegMediaCaptureSession *>(sessionIn);
++ Q_ASSERT(session);
++ m_session = session;
++ }
++
++ bool QSckWindowCapture::setActiveInternal(bool active)
++ {
++ struct ErrorPair {
++ QPlatformSurfaceCapture::Error err;
++ QString msg;
++ };
++
++ using TryStartResult = q23::expected<std::unique_ptr<ActiveData>, ErrorPair>;
++
++ auto tryStartStream = [&]() -> TryStartResult {
++ QCapturableWindow capturableWindow = source<WindowSource>();
++ const QCapturableWindowPrivate *handle = QCapturableWindowPrivate::handle(capturableWindow);
++ if (!handle) {
++ return q23::unexpected{ ErrorPair{
++ QPlatformSurfaceCapture::Error::NotFound,
++ u"Selected window is null"_s } };
++ }
++ CGWindowID cgWindowId = static_cast<CGWindowID>(handle->id);
++
++ // Find the associated SCWindow we can use.
++ // This will trigger the system dialog for granting screen capture permissions.
++ q23::expected<AVFScopedPointer<SCWindow>, QString> scWindowResult = findScWindow(cgWindowId);
++ if (!scWindowResult) {
++ qCWarning(qLcMacScreenCapture)
++ << "Could not find associated SCWindow:"
++ << scWindowResult.error();
++ return q23::unexpected{ ErrorPair {
++ QPlatformSurfaceCapture::Error::NotFound,
++ u"Backend was unable to find selected QCapturableWindow"_s } };
++ }
++
++ QMacScreenCaptureKit::StreamId newStreamId = allocateStreamId();
++
++ AVFScopedPointer<SCWindow> &scWindow = *scWindowResult;
++
++ // Tell capturesession to setup initial connections ahead
++ // of time as to not drop initial frames.
++ if (m_session)
++ m_session->onSourceActivating(*this);
++
++ QMacScreenCaptureKit::CreateStreamInfo createInfo = {};
++ createInfo.streamId = newStreamId;
++ createInfo.connectionSetupFn = [&](QMacScreenCaptureKit &newObject) {
++ setupQMacScreenCaptureKitConnections(*this, newObject);
++ };
++ createInfo.streamSettings.frameRate = frameRate();
++ createInfo.streamSettings.overrideIgnoreCursor = ignoreCursor();
++
++ // Start and wait for the stream to start. Blocking operation.
++ using ResultType = q23::expected<std::unique_ptr<QMacScreenCaptureKit>, QString>;
++ std::future<ResultType> streamResultFuture = QMacScreenCaptureKit::createStreamFromWindow(
++ createInfo,
++ scWindow.data());
++
++ ResultType streamResult = streamResultFuture.get();
++ if (!streamResult) {
++ // Tell capturesession to restore previous state.
++ if (m_session)
++ m_session->onSourceActivationFailure(*this);
++
++ qCWarning(qLcMacScreenCapture)
++ << "Failed to start screen capture stream:"
++ << streamResult.error();
++ return q23::unexpected{ ErrorPair{
++ QPlatformSurfaceCapture::Error::CaptureFailed,
++ u"Failed to start stream due to unknown issue"_s } };
++ }
++
++ std::unique_ptr<QMacScreenCaptureKit> &macScreenCaptureKit = *streamResult;
++
++ auto newActiveData = std::make_unique<ActiveData>();
++ newActiveData->macScreenCaptureKit = std::move(macScreenCaptureKit);
++ newActiveData->scWindow = std::move(scWindow);
++ newActiveData->streamId = newStreamId;
++ return newActiveData;
++ };
++
++ if (active) {
++ Q_ASSERT(!m_activeData);
++
++ TryStartResult result = tryStartStream();
++ if (!result) {
++ const ErrorPair &error = result.error();
++ QPlatformSurfaceCapture::updateError(error.err, error.msg);
++ return false;
++ }
++
++ m_activeData = std::move(*result);
++ } else {
++ m_activeData.reset();
++ }
++
++ return true;
++ }
++
++ void QSckWindowCapture::onNewFrameFormatReceived(
++ QMacScreenCaptureKit::StreamId incomingStreamId,
++ QVideoFrameFormat const &format)
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ if (activeStreamId() == incomingStreamId)
++ m_videoFrameFormat = format;
++ }
++
++ void QSckWindowCapture::onStreamStoppedWithErrorEvent(
++ QMacScreenCaptureKit::StreamId incomingStreamId,
++ const QString &err)
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++
++ qCDebug(qLcMacScreenCapture)
++ << "Stream with ID"
++ << static_cast<int64_t>(incomingStreamId)
++ << "stopped with error:"
++ << err;
++
++ if (activeStreamId() != incomingStreamId)
++ return;
++
++ // Possible improvement may be to propagate signal up to QVideoSource
++ // that we are no longer active.
++ m_activeData.reset();
++ m_videoFrameFormat.reset();
++
++ QPlatformSurfaceCapture::updateError(
++ Error::CaptureFailed,
++ u"The capture stream was closed by the system"_s);
++ }
++
++ QVideoFrameFormat QSckWindowCapture::frameFormat() const
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++
++ if (m_videoFrameFormat)
++ return *m_videoFrameFormat;
++ return {};
++ }
++
++ std::optional<int> QSckWindowCapture::ffmpegHWPixelFormat() const
++ {
++ Q_ASSERT(thread()->isCurrentThread());
++ return AV_PIX_FMT_VIDEOTOOLBOX;
++ }
++
++ std::unique_ptr<QPlatformSurfaceCapture> makeQSckWindowCapture()
++ {
++ return std::make_unique<QSckWindowCapture>();
++ }
++
++ } // namespace QFFmpeg
++
++ QT_END_NAMESPACE
++
++ #include "moc_qsckwindowcapture_p.cpp"