qx11surfacecapture.cpp

++ // Copyright (C) 2023 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 "qx11surfacecapture_p.h"

++ #include <QtMultimedia/private/qsurfacecapturegrabber_p.h>

++

++ #include <qvideoframe.h>

++ #include <qscreen.h>

++ #include <qwindow.h>

++ #include <qdebug.h>

++ #include <qguiapplication.h>

++ #include <qloggingcategory.h>

++ #include <qminmax.h>

++

++ #include "private/qcapturablewindow_p.h"

++ #include "private/qmemoryvideobuffer_p.h"

++ #include "private/qvideoframeconversionhelper_p.h"

++ #include "private/qvideoframe_p.h"

++

++ #include <X11/Xlib.h>

++ #include <sys/shm.h>

++ #include <X11/extensions/XShm.h>

++ #include <X11/Xutil.h>

++ #include <X11/extensions/Xrandr.h>

++

++ #include <optional>

++ #include <utility>

++

++ QT_BEGIN_NAMESPACE

++

++ Q_STATIC_LOGGING_CATEGORY(qLcX11SurfaceCapture, "qt.multimedia.ffmpeg.qx11surfacecapture");

++

++ namespace {

++

++ void destroyXImage(XImage* image) {

++     XDestroyImage(image); // macro

++ }

++

++ template <typename T, typename D>

++ std::unique_ptr<T, D> makeXUptr(T* ptr, D deleter) {

++    return std::unique_ptr<T, D>(ptr, deleter);

++ }

++

++ int screenNumberByName(Display *display, const QString &name)

++ {

++     int size = 0;

++     auto monitors = makeXUptr(

++             XRRGetMonitors(display, XDefaultRootWindow(display), true, &size),

++                 &XRRFreeMonitors);

++     const auto end = monitors.get() + size;

++     auto found = std::find_if(monitors.get(), end, [&](const XRRMonitorInfo &info) {

++         auto atomName = makeXUptr(XGetAtomName(display, info.name), &XFree);

++         return atomName && name == QString::fromUtf8(atomName.get());

++     });

++

++     return found == end ? -1 : std::distance(monitors.get(), found);

++ }

++

++ QVideoFrameFormat::PixelFormat xImagePixelFormat(const XImage &image)

++ {

++     if (image.bits_per_pixel != 32) return QVideoFrameFormat::Format_Invalid;

++

++     if (image.red_mask == 0xff0000 &&

++         image.green_mask == 0xff00 &&

++         image.blue_mask == 0xff)

++         return QVideoFrameFormat::Format_BGRX8888;

++

++     if (image.red_mask == 0xff00 &&

++         image.green_mask == 0xff0000 &&

++         image.blue_mask == 0xff000000)

++         return QVideoFrameFormat::Format_XBGR8888;

++

++     if (image.blue_mask == 0xff0000 &&

++         image.green_mask == 0xff00 &&

++         image.red_mask == 0xff)

++         return QVideoFrameFormat::Format_RGBX8888;

++

++     if (image.red_mask == 0xff00 &&

++         image.green_mask == 0xff0000 &&

++         image.blue_mask == 0xff000000)

++         return QVideoFrameFormat::Format_XRGB8888;

++

++     return QVideoFrameFormat::Format_Invalid;

++ }

++

++ } // namespace

++

++ class QX11SurfaceCapture::Grabber : public QSurfaceCaptureGrabber

++ {

++ public:

++     static std::unique_ptr<Grabber> create(QX11SurfaceCapture &capture, QScreen *screen)

++     {

++         std::unique_ptr<Grabber> result(new Grabber(capture));

++         return result->init(screen) ? std::move(result) : nullptr;

++     }

++

++     static std::unique_ptr<Grabber> create(QX11SurfaceCapture &capture, WId wid)

++     {

++         std::unique_ptr<Grabber> result(new Grabber(capture));

++         return result->init(wid) ? std::move(result) : nullptr;

++     }

++

++     ~Grabber() override

++     {

++         stop();

++

++         detachShm();

++     }

++

++     const QVideoFrameFormat &format() const { return m_format; }

++

++ private:

++     Grabber(QX11SurfaceCapture &capture) : QSurfaceCaptureGrabber()

++     {

++         addFrameCallback(&capture, &QX11SurfaceCapture::newVideoFrame);

++         connect(this, &Grabber::errorUpdated, &capture, &QX11SurfaceCapture::updateError);

++

++         m_userFrameRate = capture.frameRate();

++     }

++

++     bool createDisplay()

++     {

++         if (!m_display)

++             m_display.reset(XOpenDisplay(nullptr));

++

++         if (!m_display)

++             updateError(QPlatformSurfaceCapture::Error::InternalError,

++                         QStringLiteral("Cannot open X11 display"));

++

++         return m_display != nullptr;

++     }

++

++     bool init(WId wid)

++     {

++         const auto defaultRate = QGuiApplication::primaryScreen()

++                 ? qMin(QGuiApplication::primaryScreen()->refreshRate(),

++                        DefaultScreenCaptureFrameRate)

++                 : DefaultScreenCaptureFrameRate;

++         setFrameRate(m_userFrameRate.value_or(defaultRate));

++

++         return createDisplay() && initWithXID(static_cast<XID>(wid));

++     }

++

++     bool init(QScreen *screen)

++     {

++         if (!screen) {

++             updateError(QPlatformSurfaceCapture::Error::NotFound, QStringLiteral("Screen Not Found"));

++             return false;

++         }

++

++         if (!createDisplay())

++             return false;

++

++         auto screenNumber = screenNumberByName(m_display.get(), screen->name());

++

++         if (screenNumber < 0)

++             return false;

++

++         setFrameRate(m_userFrameRate.value_or(

++                 qMin(screen->refreshRate(), DefaultScreenCaptureFrameRate)));

++

++         return initWithXID(RootWindow(m_display.get(), screenNumber));

++     }

++

++     bool initWithXID(XID xid)

++     {

++         m_xid = xid;

++

++         if (update()) {

++             start();

++             return true;

++         }

++

++         return false;

++     }

++

++     void detachShm()

++     {

++         if (std::exchange(m_attached, false)) {

++             XShmDetach(m_display.get(), &m_shmInfo);

++             shmdt(m_shmInfo.shmaddr);

++             shmctl(m_shmInfo.shmid, IPC_RMID, nullptr);

++         }

++     }

++

++     void attachShm()

++     {

++         Q_ASSERT(!m_attached);

++

++         m_shmInfo.shmid =

++                 shmget(IPC_PRIVATE, m_xImage->bytes_per_line * m_xImage->height, IPC_CREAT | 0777);

++

++         if (m_shmInfo.shmid == -1)

++             return;

++

++         m_shmInfo.readOnly = false;

++         m_shmInfo.shmaddr = m_xImage->data = (char *)shmat(m_shmInfo.shmid, nullptr, 0);

++

++         m_attached = XShmAttach(m_display.get(), &m_shmInfo);

++     }

++

++     bool update()

++     {

++         Window win = m_xid;

++         XWindowAttributes wndattr;

++         int xPos = 0;

++         int yPos = 0;

++         int width = 0;

++         int height = 0;

++         int depth = 0;

++         Visual *visual = nullptr;

++         while (true) {

++             if (!XGetWindowAttributes(m_display.get(), win, &wndattr)) {

++                 updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                             QStringLiteral("Cannot get window attributes"));

++                 return false;

++             }

++             if (win == m_xid) {

++                 if (wndattr.map_state != IsViewable) {

++                     updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                                 QStringLiteral("Window is not viewable"));

++                     return false;

++                 }

++                 width = wndattr.width;

++                 height = wndattr.height;

++                 depth = wndattr.depth;

++                 visual = wndattr.visual;

++             }

++             if (win == wndattr.root)

++                 break;

++             xPos += wndattr.x;

++             yPos += wndattr.y;

++

++             Window root, *children;

++             unsigned int nchildren;

++             if (!XQueryTree(m_display.get(), win, &root, &win, &children, &nchildren)) {

++                 updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                             QStringLiteral("Cannot get parent window"));

++                 return false;

++             }

++             if (children) XFree(children);

++         }

++

++         m_xOffset = qMax(0, -xPos);

++         m_yOffset = qMax(0, -yPos);

++         width = qMin(width, wndattr.width - xPos) - m_xOffset;

++         height = qMin(height, wndattr.height - yPos) - m_yOffset;

++         if (width <= 0 || height <= 0) {

++             updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                         QStringLiteral("Window is completely out of the screen borders"));

++             return false;

++         }

++

++         // check window params for the root window as well since

++         // it potentially can be changed (e.g. on VM with resizing)

++         if (!m_xImage || width != m_xImage->width || height != m_xImage->height

++             || depth != m_xImage->depth || visual->visualid != m_visualID) {

++

++             qCDebug(qLcX11SurfaceCapture) << "recreate ximage: " << width << height

++                                           << depth << visual->visualid;

++

++             detachShm();

++             m_xImage.reset();

++

++             m_visualID = wndattr.visual->visualid;

++             m_xImage.reset(XShmCreateImage(m_display.get(), visual, depth, ZPixmap,

++                                            nullptr, &m_shmInfo, width, height));

++

++             if (!m_xImage) {

++                 updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                             QStringLiteral("Cannot create image"));

++                 return false;

++             }

++

++             const auto pixelFormat = xImagePixelFormat(*m_xImage);

++

++             // TODO: probably, add a converter instead

++             if (pixelFormat == QVideoFrameFormat::Format_Invalid) {

++                 updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                             QStringLiteral("Not handled pixel format, bpp=")

++                                     + QString::number(m_xImage->bits_per_pixel));

++                 return false;

++             }

++

++             attachShm();

++

++             if (!m_attached) {

++                 updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                             QStringLiteral("Cannot attach shared memory"));

++                 return false;

++             }

++

++             QVideoFrameFormat format(QSize(m_xImage->width, m_xImage->height), pixelFormat);

++             format.setStreamFrameRate(activeFrameRate());

++             m_format = format;

++         }

++

++         return m_attached;

++     }

++

++ protected:

++     QVideoFrame grabFrame() override

++     {

++         if (!grabXImage())

++             return {};

++

++         QByteArray data(m_xImage->bytes_per_line * m_xImage->height, Qt::Uninitialized);

++

++         const auto pixelSrc = reinterpret_cast<const uint32_t *>(m_xImage->data);

++         const auto pixelDst = reinterpret_cast<uint32_t *>(data.data());

++         const auto pixelCount = data.size() / 4;

++         const auto xImageAlphaVaries = false; // In known cases it doesn't vary - it's 0xff or 0xff

++

++         qCopyPixelsWithAlphaMask(pixelDst, pixelSrc, pixelCount, m_format.pixelFormat(),

++                                        xImageAlphaVaries);

++

++         auto buffer = std::make_unique<QMemoryVideoBuffer>(data, m_xImage->bytes_per_line);

++         return QVideoFramePrivate::createFrame(std::move(buffer), m_format);

++     }

++

++ private:

++     bool grabXImage()

++     {

++         for (int i = 0; i < 10; i++) {

++             if (!update())

++                 return false;

++             if (XShmGetImage(m_display.get(), m_xid, m_xImage.get(),

++                              m_xOffset, m_yOffset, AllPlanes))

++                 return true;

++         }

++

++         updateError(QPlatformSurfaceCapture::Error::CaptureFailed,

++                     QStringLiteral(

++                         "Cannot get ximage; the window geometry may be undergoing change"));

++         return false;

++     }

++

++     std::optional<QPlatformSurfaceCapture::Error> m_prevGrabberError;

++     XID m_xid = None;

++     int m_xOffset = 0;

++     int m_yOffset = 0;

++     std::unique_ptr<Display, decltype(&XCloseDisplay)> m_display{ nullptr, &XCloseDisplay };

++     std::unique_ptr<XImage, decltype(&destroyXImage)> m_xImage{ nullptr, &destroyXImage };

++     XShmSegmentInfo m_shmInfo{};

++     bool m_attached = false;

++     VisualID m_visualID = None;

++     QVideoFrameFormat m_format;

++     std::optional<qreal> m_userFrameRate;

++ };

++

++ QX11SurfaceCapture::QX11SurfaceCapture(Source initialSource)

++     : QPlatformSurfaceCapture(std::move(initialSource))

++ {

++     // For debug

++     //  XSetErrorHandler([](Display *, XErrorEvent * e) {

++     //      qDebug() << "error handler" << e->error_code;

++     //      return 0;

++     //  });

++ }

++

++ QX11SurfaceCapture::~QX11SurfaceCapture() = default;

++

++ QVideoFrameFormat QX11SurfaceCapture::frameFormat() const

++ {

++     return m_grabber ? m_grabber->format() : QVideoFrameFormat{};

++ }

++

++ bool QX11SurfaceCapture::setActiveInternal(bool active)

++ {

++     qCDebug(qLcX11SurfaceCapture) << "set active" << active;

++

++     if (m_grabber)

++         m_grabber.reset();

++     else

++         std::visit([this](const auto &source) {

++             activate(source);

++         }, source());

++

++     return static_cast<bool>(m_grabber) == active;

++ }

++

++ void QX11SurfaceCapture::activate(ScreenSource screen)

++ {

++     if (checkScreenWithError(screen))

++         m_grabber = Grabber::create(*this, screen);

++ }

++

++ void QX11SurfaceCapture::activate(const WindowSource &window)

++ {

++     auto handle = QCapturableWindowPrivate::handle(window);

++     m_grabber = Grabber::create(*this, handle ? handle->id : 0);

++ }

++

++ bool QX11SurfaceCapture::isSupported()

++ {

++     return qgetenv("XDG_SESSION_TYPE").compare(QLatin1String("x11"), Qt::CaseInsensitive) == 0;

++ }

++

++ QT_END_NAMESPACE

Revision control